Skip to contentSkip to conversation

mm, drm/xe: Avoid reclaim/eviction loops under fragmentation

PATCH In review Matthew Brost 5 participants 14 messages Jun 17 – Jul 31

Subsystems (7)
lore
Share & tools
lore

Matthew Brost

author maintainer
#0 lore raw

v6 cover mm, drm/xe: Avoid reclaim/eviction loops under fragmentation

Continuation of [1].

TTM allocations at higher orders can drive Xe into a pathological reclaim loop when memory is fragmented:

kswapd → shrinker → eviction → rebind (exec ioctl) → repeat

In this state, reclaim is triggered despite substantial free memory, but fails to produce contiguous higher-order pages. The Xe shrinker then evicts active buffer objects, increasing faulting and rebind activity and further feeding the loop. The result is high CPU overhead and poor GPU forward progress.

This issue was first reported in [2] and independently observed internally and by Google.

A simple reproducer is:

- Boot an iGPU system with mem=8G
- Launch 10 Chrome tabs running the WebGL aquarium demo
- Configure each tab with ~5k fish

Under this workload, ftrace shows a continuous loop of:

xe_shrinker_scan (kswapd)
xe_vma_rebind_exec

Performance degrades significantly, with each tab dropping to ~2 FPS on PTL (Ubuntu 24.04).

At the same time, /proc/buddyinfo shows substantial free memory but no higher-order availability. For example, the Normal zone:

Count: 4063 4595 3455 3400 3139 2762 2293 1655 643 0 0

This corresponds to ~2.8GB free memory, but no order-9 (2MB) blocks, indicating severe fragmentation.

This series addresses the issue in two layers:

MM: Introduce an opportunistic_compaction hint in shrink_control. kswapd folds the gfp flags of its wakers into a per-pgdat tri-state (see enum kswapd_opportunistic_compaction_type) and forwards it to shrinkers. The hint is set when every waker for a kswapd run is a failable high-order allocation (__GFP_NORETRY or __GFP_RETRY_MAYFAIL, without __GFP_NOFAIL) — i.e. callers that would rather see the allocation fail than have working sets torn down to satisfy it. Any order-0 or non-failable waker clears the hint for that run, so normal memory pressure is unaffected. Similarly direct recliam sets the opportunistic_compaction hint based caller's gfp_mask and order.

Xe: Consume shrink_control::opportunistic_compaction in the Xe shrinker. When the hint is set for a high-order pass, the shrinker skips advertising and performing TTM backup work — which operates at native page order and would not help compaction — and avoids tearing down active GPU working sets.

With these changes, the reclaim/eviction loop is eliminated. The same workload improves to ~10 FPS per tab (Ubuntu 24.04) or ~15 FPS per tab (Ubuntu 24.10), and kswapd activity subsides.

Buddyinfo after applying this series shows restored higher-order availability:

Count: 8526 7067 3092 1959 1292 660 194 28 20 13 1

In addition various 3D benchmarks show signicant improvement memory is fragmented.

v2:
- Layer with core MM / TTM helpers (Thomas)
v4:
- Fix build (CI)
v5:
- Use shrinker based heurstics (Dave Chinner, Thomas's GFP idea)
- Rename lazy_compaction → opportunistic_compaction
v6:
- Drop order in shrink_control rely only on opportunistic_compaction hint (Testing)
- Set opportunistic_compaction in direct reclaim (Testing)
- Drop unrelated TTM which merged independently

[1] https://patchwork.freedesktop.org/series/165329/
[2] https://patchwork.freedesktop.org/patch/716404/?series=164353&rev=1

Cc Dave Chinner <[email protected]>
Cc Qi Zheng <[email protected]>
Cc Roman Gushchin <[email protected]>
Cc Johannes Weiner <[email protected]>
Cc Shakeel Butt <[email protected]>
Cc Kairui Song <[email protected]>
Cc Barry Song <[email protected]>
Cc Axel Rasmussen <[email protected]>
Cc Yuanchu Xie <[email protected]>
Cc Wei Xu <[email protected]>
Cc Tvrtko Ursulin <[email protected]>
Cc Thomas Hellström <[email protected]>
Cc Carlos Santa <[email protected]>
Cc Christian Koenig <[email protected]>
Cc Huang Rui <[email protected]>
Cc Matthew Auld <[email protected]>
Cc Matthew Brost <[email protected]>
Cc Maarten Lankhorst <[email protected]>
Cc Maxime Ripard <[email protected]>
Cc Thomas Zimmermann <[email protected]>
Cc David Airlie <[email protected]>
Cc Simona Vetter <[email protected]>
Cc Daniel Colascione <[email protected]>
Cc Andrew Morton <[email protected]>
Cc David Hildenbrand <[email protected]>
Cc Lorenzo Stoakes <[email protected]>
Cc "Liam R. Howlett" <[email protected]>
Cc Vlastimil Babka <[email protected]>
Cc Mike Rapoport <[email protected]>
Cc Suren Baghdasaryan <[email protected]>
Cc Michal Hocko <[email protected]>

Matthew Brost (2):
mm: Introduce opportunistic_compaction concept to vmscan and shrinkers drm/xe: Make use of shrink_control::opportunistic_compaction hint

 drivers/gpu/drm/xe/xe_shrinker.c | 20 ++++++-
 include/linux/mmzone.h           | 40 ++++++++++++++
 include/linux/shrinker.h         | 20 +++++++
 mm/internal.h                    |  2 +-
 mm/shrinker.c                    | 13 +++--
 mm/vmscan.c                      | 95 +++++++++++++++++++++++++++++---
 6 files changed, 174 insertions(+), 16 deletions(-)
Signature · 1 line
2.34.1
author maintainer
#1 lore raw

PATCH v6 1/2 mm: Introduce opportunistic_compaction concept to vmscan and shrinkers

High-order allocations using __GFP_NORETRY or __GFP_RETRY_MAYFAIL are often opportunistic attempts to satisfy fragmentation-sensitive allocations rather than indications of severe memory pressure. In these cases, reclaim may invoke shrinkers that aggressively destroy working sets even though reclaim is unlikely to materially improve the allocation outcome.

Some shrinkers manage expensive backing or migration operations where reclaim can result in substantial working set disruption despite the system having sufficient free memory overall. This is particularly visible in fragmentation-heavy workloads where reclaim repeatedly tears down active state while kswapd attempts to satisfy higher-order allocations.

Introduce an opportunistic_compaction hint in shrink_control that allows kswapd to communicate when reclaim originates from a high-order allocation context that may be fragmentation driven rather than true memory pressure. Shrinkers may use this hint to avoid destructive working set reclaim while still participating normally during order-0 or stronger reclaim conditions.

The hint is propagated through shrink_slab() and derived from high-order kswapd wakeups associated or direct reclaim gfp with non-failing allocation contexts.

No functional changes are introduced for existing shrinkers.

Cc Andrew Morton <[email protected]>
Cc Dave Chinner <[email protected]>
Cc Qi Zheng <[email protected]>
Cc Roman Gushchin <[email protected]>
Cc Muchun Song <[email protected]>
Cc David Hildenbrand <[email protected]>
Cc Lorenzo Stoakes <[email protected]>
Cc "Liam R. Howlett" <[email protected]>
Cc Vlastimil Babka <[email protected]>
Cc Mike Rapoport <[email protected]>
Cc Suren Baghdasaryan <[email protected]>
Cc Michal Hocko <[email protected]>
Cc Johannes Weiner <[email protected]>
Cc Shakeel Butt <[email protected]>
Cc Kairui Song <[email protected]>
Cc Barry Song <[email protected]>
Cc Axel Rasmussen <[email protected]>
Cc Yuanchu Xie <[email protected]>
Cc Wei Xu <[email protected]>
Assisted-by Claude:claude-opus-4.6

---

Dave Chinner — I’d appreciate feedback on this approach, as you NACKed an earlier revision where a similar heuristic was implemented in the drivers. It is now baked into the shrinker, as you suggested.

---
 include/linux/mmzone.h   | 40 +++++++++++++++++
 include/linux/shrinker.h | 20 +++++++++
 mm/internal.h            |  2 +-
 mm/shrinker.c            | 13 ++++--
 mm/vmscan.c              | 95 ++++++++++++++++++++++++++++++++++++----
 5 files changed, 157 insertions(+), 13 deletions(-)
include/linux/mmzone.h +40 -0
index 9adb2ad21da5..1afc51018355 100644
@@ -1461,6 +1461,39 @@ struct memory_failure_stats {
 };
 #endif
 
+/*
+ * Per-pgdat state machine for the kswapd "opportunistic compaction" hint.
+ *
+ * wakeup_kswapd() collapses the gfp flags of all wakers that arrive between
+ * two kswapd runs into a single tri-state, which kswapd then forwards to the
+ * shrinkers via shrink_control::opportunistic_compaction:
+ *
+ *   KSWAPD_UNSET_OPPORTUNISTIC_COMPACTION
+ *	Initial state after kswapd consumes the previous value. No waker has
+ *	been observed yet for the upcoming run.
+ *
+ *   KSWAPD_NO_OPPORTUNISTIC_COMPACTION
+ *	At least one waker is an order-0 allocation, or a high-order
+ *	allocation that cannot tolerate failure (i.e., not eligible for
+ *	opportunistic behaviour). Shrinkers must do their normal best-effort
+ *	work; the hint is cleared.
+ *
+ *   KSWAPD_OPPORTUNISTIC_COMPACTION
+ *	All wakers seen so far are high-order allocations that may fail
+ *	(__GFP_NORETRY or __GFP_RETRY_MAYFAIL, without __GFP_NOFAIL). Shrinkers
+ *	may skip work that is unlikely to produce a contiguous high-order
+ *	block (e.g., evicting working-set pages).
+ *
+ * The state is sticky in the "NO" direction within a single kswapd run: once
+ * any non-eligible waker is observed, subsequent eligible wakers cannot
+ * upgrade it back to KSWAPD_OPPORTUNISTIC_COMPACTION.
+ */
+enum kswapd_opportunistic_compaction_type {
+	KSWAPD_UNSET_OPPORTUNISTIC_COMPACTION = 0,
+	KSWAPD_NO_OPPORTUNISTIC_COMPACTION,
+	KSWAPD_OPPORTUNISTIC_COMPACTION,
+};
+
 /*
  * On NUMA machines, each NUMA node would have a pg_data_t to describe
  * it's memory layout. On UMA machines there is a single pglist_data which
@@ -1525,6 +1558,13 @@ typedef struct pglist_data {
 #endif
 	struct task_struct *kswapd;	/* Protected by kswapd_lock */
 	int kswapd_order;
+	/*
+	 * Aggregated opportunistic-compaction hint for the next kswapd run.
+	 * Updated by wakeup_kswapd() based on the gfp flags / order of each
+	 * waker, and consumed (and reset) by kswapd before balance_pgdat().
+	 * See enum kswapd_opportunistic_compaction_type for the state machine.
+	 */
+	atomic_t kswapd_opportunistic_compaction;
 	enum zone_type kswapd_highest_zoneidx;
 
 	atomic_t kswapd_failures;	/* Number of 'reclaimed == 0' runs */
include/linux/shrinker.h +20 -0
index 1a00be90d93a..5f3e8dc98129 100644
@@ -37,6 +37,26 @@ struct shrink_control {
 	/* current node being shrunk (for NUMA aware shrinkers) */
 	int nid;
 
+	/*
+	 * Opportunistic compaction hint.
+	 *
+	 * Set by the reclaim path to tell shrinkers that this pass is
+	 * driven by an order > 0 allocation that the caller is willing to
+	 * have fail (e.g., __GFP_NORETRY / __GFP_RETRY_MAYFAIL without
+	 * __GFP_NOFAIL). Such allocations only really benefit from
+	 * shrinking when doing so frees up a contiguous, high-order block;
+	 * thrashing working sets in the hope of producing one is typically
+	 * counter-productive.
+	 *
+	 * Shrinkers that can produce naturally-aligned high-order folios
+	 * (see shrink_control::order) should treat this as a hint to skip
+	 * costly work that is unlikely to help compaction (for example,
+	 * evicting hot/working-set pages just to free single pages).
+	 *
+	 * Only meaningful when @order > 0; ignored otherwise.
+	 */
+	bool opportunistic_compaction;
+
 	/*
 	 * How many objects scan_objects should scan and try to reclaim.
 	 * This is reset before every call, so it is safe for callees
mm/internal.h +1 -1
index 5a2ddcf68e0b..cc915f04cf1e 100644
@@ -1760,7 +1760,7 @@ void __meminit __init_page_from_nid(unsigned long pfn, int nid);
 
 /* shrinker related functions */
 unsigned long shrink_slab(gfp_t gfp_mask, int nid, struct mem_cgroup *memcg,
-			  int priority);
+			  int priority, bool opportunistic_compaction);
 
 int shmem_add_to_page_cache(struct folio *folio,
 			    struct address_space *mapping,
mm/shrinker.c +9 -4
index 76b3f750cf65..2cf8f3a157f9 100644
@@ -467,7 +467,7 @@ static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,
 
 #ifdef CONFIG_MEMCG
 static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
-			struct mem_cgroup *memcg, int priority)
+			struct mem_cgroup *memcg, int priority, bool opportunistic_compaction)
 {
 	struct shrinker_info *info;
 	unsigned long ret, freed = 0;
@@ -529,6 +529,7 @@ static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
 				.gfp_mask = gfp_mask,
 				.nid = nid,
 				.memcg = memcg,
+				.opportunistic_compaction = opportunistic_compaction,
 			};
 			struct shrinker *shrinker;
 			int shrinker_id = calc_shrinker_id(index, offset);
@@ -588,7 +589,8 @@ static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
 }
 #else /* !CONFIG_MEMCG */
 static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
-			struct mem_cgroup *memcg, int priority)
+			struct mem_cgroup *memcg, int priority,
+			bool opportunistic_compaction)
 {
 	return 0;
 }
@@ -600,6 +602,7 @@ static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
  * @nid: node whose slab caches to target
  * @memcg: memory cgroup whose slab caches to target
  * @priority: the reclaim priority
+ * @opportunistic_compaction: do compaction opportunistically (e.g., do not swap working sets)
  *
  * Call the shrink functions to age shrinkable caches.
  *
@@ -615,7 +618,7 @@ static unsigned long shrink_slab_memcg(gfp_t gfp_mask, int nid,
  * Returns the number of reclaimed slab objects.
  */
 unsigned long shrink_slab(gfp_t gfp_mask, int nid, struct mem_cgroup *memcg,
-			  int priority)
+			  int priority, bool opportunistic_compaction)
 {
 	unsigned long ret, freed = 0;
 	struct shrinker *shrinker;
@@ -628,7 +631,8 @@ unsigned long shrink_slab(gfp_t gfp_mask, int nid, struct mem_cgroup *memcg,
 	 * oom.
 	 */
 	if (!mem_cgroup_disabled() && !mem_cgroup_is_root(memcg))
-		return shrink_slab_memcg(gfp_mask, nid, memcg, priority);
+		return shrink_slab_memcg(gfp_mask, nid, memcg, priority,
+					 opportunistic_compaction);
 
 	/*
 	 * lockless algorithm of global shrink.
@@ -657,6 +661,7 @@ unsigned long shrink_slab(gfp_t gfp_mask, int nid, struct mem_cgroup *memcg,
 			.gfp_mask = gfp_mask,
 			.nid = nid,
 			.memcg = memcg,
+			.opportunistic_compaction = opportunistic_compaction,
 		};
 
 		if (!shrinker_try_get(shrinker))
mm/vmscan.c +87 -8

198 lines not on this page · raw message

Signature · 1 line
2.34.1
#2 lore raw

Re: [PATCH v6 1/2] mm: Introduce opportunistic_compaction concept to vmscan and shrinkers

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider: - [High] Concurrent order-0 wakers cause opportunistic high-order kswapd reclaims to become destructive…

Thank you for your contribution! Sashiko AI review found 3 potential issue(s) to consider:
- [High] Concurrent order-0 wakers cause opportunistic high-order kswapd reclaims to become destructive, defeating the patch's purpose.
- [High] The opportunistic compaction hint decays to UNSET on retries and premature wakeups, silently converting opportunistic reclaim into destructive reclaim.
- [Medium] The order field referenced in struct shrink_control's documentation is missing from the struct, rendering the API incomplete. --

commit 458389aa250d63553aa4e2e1f9e0c39d7fbae43e
Author: Matthew Brost <[email protected]>
Subject: mm: Introduce opportunistic_compaction concept to vmscan and shrinkers

This commit introduces an opportunistic compaction hint for kswapd and shrinkers. It aims to prevent aggressive reclaim of working sets during fragmentation-sensitive high-order allocations. Shrinkers can use this hint to skip destructive work when reclaim is unlikely to produce a contiguous high-order block.

Quoted 17 lines
include/linux/shrinker.h +9 -0
index 1a00be90d93a9..5f3e8dc981296 100644
@@ -37,6 +37,26 @@ struct shrink_control {
 	/* current node being shrunk (for NUMA aware shrinkers) */
 	int nid;
 
+	/*
+	 * Opportunistic compaction hint.
+	 *
+	 * Set by the reclaim path to tell shrinkers that this pass is
+	 * driven by an order > 0 allocation that the caller is willing to
+	 * have fail (e.g., __GFP_NORETRY / __GFP_RETRY_MAYFAIL without
+	 * __GFP_NOFAIL). Such allocations only really benefit from
+	 * shrinking when doing so frees up a contiguous, high-order block;
+	 * thrashing working sets in the hope of producing one is typically

include/linux/shrinker.h struct shrink_control { · line 58

Quoted 10 lines
include/linux/shrinker.h +10 -0
+	 * counter-productive.
+	 *
+	 * Shrinkers that can produce naturally-aligned high-order folios
+	 * (see shrink_control::order) should treat this as a hint to skip
+	 * costly work that is unlikely to help compaction (for example,
+	 * evicting hot/working-set pages just to free single pages).
+	 *
+	 * Only meaningful when @order > 0; ignored otherwise.
+	 */
+	bool opportunistic_compaction;

[Severity: Medium]
The comment references a shrink_control::order field, but does this field actually exist in struct shrink_control?

Without passing the target allocation order from scan_control through shrink_slab(), it seems shrinker implementations won't be able to determine the requested block size to conditionally skip work.

Quoted 4 lines
mm/vmscan.c +0 -0
index bd1b1aa125819..c40bc3f9ddd43 100644

[ ... ]

mm/vmscan.c static void kswapd_try_to_sleep(pg_data_t *pgdat, int alloc_order, int reclaim_o · line 7438

Quoted 12 lines
mm/vmscan.c +5 -0
@@ -7385,6 +7428,11 @@ static void kswapd_try_to_sleep(pg_data_t *pgdat, int alloc_order, int reclaim_o
 
 			if (READ_ONCE(pgdat->kswapd_order) < reclaim_order)
 				WRITE_ONCE(pgdat->kswapd_order, reclaim_order);
+
+			if (kswapd_opportunistic_compaction ==
+			    KSWAPD_NO_OPPORTUNISTIC_COMPACTION)
+				atomic_set(&pgdat->kswapd_opportunistic_compaction,
+					   KSWAPD_NO_OPPORTUNISTIC_COMPACTION);
 		}
 
 		finish_wait(&pgdat->kswapd_wait, &wait);

[Severity: High]
Does this conditional block inadvertently allow the opportunistic hint to decay on retries?

In kswapd(), the hint is extracted and reset to KSWAPD_UNSET_OPPORTUNISTIC_COMPACTION before calling balance_pgdat().

If the first reclaim pass fails and kswapd goes back to sleep, this code only restores the hint if it was KSWAPD_NO_OPPORTUNISTIC_COMPACTION. If it was KSWAPD_OPPORTUNISTIC_COMPACTION, the state decays to UNSET.

On the subsequent retry, sc_opportunistic_compaction() will evaluate UNSET as false, meaning a multi-pass reclaim or premature wakeup will cause kswapd to resume full destructive reclaim for the high-order allocation.

[ ... ]

Quoted 15 lines
mm/vmscan.c +11 -0
@@ -7537,6 +7594,28 @@ void wakeup_kswapd(struct zone *zone, gfp_t gfp_flags, int order,
 	if (READ_ONCE(pgdat->kswapd_order) < order)
 		WRITE_ONCE(pgdat->kswapd_order, order);
 
+	/*
+	 * Fold this waker into the per-pgdat opportunistic-compaction hint
+	 * that kswapd will pick up at the start of its next run.
+	 *
+	 * The state is sticky in the "NO" direction: once any waker in this
+	 * batch is order-0 or a non-failable high-order allocation, the hint
+	 * stays cleared until kswapd consumes it. Only when every waker so
+	 * far is a failable high-order allocation do we set
+	 * KSWAPD_OPPORTUNISTIC_COMPACTION, asking shrinkers to skip work
+	 * that won't realistically help compaction.
+	 */

mm/vmscan.c void wakeup_kswapd(struct zone *zone, gfp_t gfp_flags, int order, · line 7617

Quoted 10 lines
mm/vmscan.c +10 -0
+	if (atomic_read(&pgdat->kswapd_opportunistic_compaction) !=
+	    KSWAPD_NO_OPPORTUNISTIC_COMPACTION) {
+		if (!order || !gfp_opportunistic_compaction(gfp_flags))
+			atomic_set(&pgdat->kswapd_opportunistic_compaction,
+				   KSWAPD_NO_OPPORTUNISTIC_COMPACTION);
+		else if (order && gfp_opportunistic_compaction(gfp_flags))
+			atomic_cmpxchg(&pgdat->kswapd_opportunistic_compaction,
+				       KSWAPD_UNSET_OPPORTUNISTIC_COMPACTION,
+				       KSWAPD_OPPORTUNISTIC_COMPACTION);
+	}

[Severity: High]
Can concurrent order-0 wakers cause opportunistic high-order kswapd reclaims to become destructive here?

Since pgdat->kswapd_order tracks the maximum requested allocation order while the hint independently aggregates with a sticky-NO approach, what happens if an opportunistic high-order allocation (e.g., order 9) and a normal order-0 allocation concurrently wake kswapd?

It appears the aggregated state becomes order=9 with KSWAPD_NO_OPPORTUNISTIC_COMPACTION. This would cause kswapd to execute balance_pgdat() for order 9 with the non-opportunistic hint, meaning shrinkers receive opportunistic_compaction = false and aggressively destroy the working set to satisfy the order-9 allocation.

Because order-0 allocations (like page cache faults) are common, does this guarantee the opportunistic compaction heuristic will be routinely bypassed under normal memory pressure?

Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#3 lore raw

Re: [PATCH v6 1/2] mm: Introduce opportunistic_compaction concept to vmscan and shrinkers

In reply to Matthew Brost
Quoted 14 lines · Matthew Brost

High-order allocations using __GFP_NORETRY or __GFP_RETRY_MAYFAIL are often opportunistic attempts to satisfy fragmentation-sensitive allocations rather than indications of severe memory pressure. In these cases, reclaim may invoke shrinkers that aggressively destroy working sets even though reclaim is unlikely to materially improve the allocation outcome.

Some shrinkers manage expensive backing or migration operations where reclaim can result in substantial working set disruption despite the system having sufficient free memory overall. This is particularly visible in fragmentation-heavy workloads where reclaim repeatedly tears down active state while kswapd attempts to satisfy higher-order allocations.

Quoted 6 lines

Introduce an opportunistic_compaction hint in shrink_control that allows kswapd to communicate when reclaim originates from a high-order allocation context that may be fragmentation driven rather than true memory pressure. Shrinkers may use this hint to avoid destructive working set reclaim while still participating normally during order-0 or stronger reclaim conditions.

To be honest, this seems like another "push a hint through to the XE shrinker" mechanism under a different name. You seem so focused on fixing the XE reproducer that the -systemic problem- that -any- high-order folio demand causes is not being acknowleged.

e.g. we use high-order folios extensively in the page cache these days, and there are -many- cases where memory compaction driven by high-order demand cause significant performance regressions for page cache performance. To date, every single person who has wanted to fix the problem they are seeing has effectively attempted to -turn off compaction- via GFP flags.

I've even done that myself inside XFS to work around kvmalloc() issues with a lack of GFP_NOFAIL support and doing costly high order allocations that fail and trigger compaction before falling back to vmalloc(). However, these issues have since been fixed in the kvmalloc() code, such that it now does the right thing for most calling contexts (i.e. tries high-order kmalloc() without triggering compaction, then fall back to GFP_NOFAIL vmalloc()). This has made kvmalloc() more performant and better behaved for -all users-, not just XFS.

This is not sustainable - we need compaction to be robust and performant in the face of high-order folio demands, regardless of what subsystem is generating the demand.

So with that in mind, let me paraphrase the comment in the second patch in the Xe shrinker implementation:

"Shrinker reclaim is based on implementation specific object sizes so it is unlikely to ever acheive contiguous page reclaim in a manner that will measurably improve compaction rates."

You also say:

Quoted 1 line

No functional changes are introduced for existing shrinkers.

Consider how many shrinkable caches the general statement above applies to, and then think about the fundamental impedence mismatch between the affected shrinkable caches and what this patch actually fixes.

For example, what happens to slab-based caches if the XE cache is being excessively reclaimed under high-order page demand? e.g. the slab-based cache may have tens of objects per page and holds a system-level performance critical working set of objects. How do these caches handle the excessive reclaim demand being generated by compaction thrashing?

Yup, they don't.

In the case of filesystem caches, the "reclaim and repopulate" pattern you describe causing the XE perf problems causes internal slab cache fragmentation. Not only does this not improve compaction rates, it also results in more memory fragmentation because slab pages get pinned by a small number of long lived objects and they won't get freed until the cache is largely emptied. IOWs, things get -even worse- from a memory fragmentation POV when compaction thrashing causes the working set of a high-object-count-per-page slab cache to thrash....

This isn't isolated to individual subsystem thrashing. If we run a file-based workload that generates high-order folio demand and hence compaction (e.g copy tens of GB of files between two XFS, ext4 or btrfs filesystems), that will -also- trash the Xe working set via the shrinker being hammered by memory compaction try to free up contiguous pages for the page cache.

Similarly, if we run a Xe workload that generates sustained high order folio demand, that will trash the working set in the dentry and inode caches and any other shrinkable slab-based cache.

Hence the abstracted case of the problem we need to solve is this:
shrinker reclaim is based on x-byte objects is extremely unlikely to acheive contiguous page reclaim in a manner that will measurably improve compaction rates.

This is a problem that has to be addresses by the high level infrastructure level, not worked around by individual shrinkers.

IMO, compaction shouldn't trigger shrinkers unless the shrinkers are specifically flagged as being able to release contiguous pages of memory in short order. I don't think there's very many shrinkable caches that even hold a significant quantity of objects larger than a single page, so it's clearly questionable as to whether compaction based reclaim should run shrinker reclaim to begin with.

i.e. a subsystem that can track high order folios in a shrinkable cache should probably have a "->compaction_scan()" method that is run directly from compaction context to try to free high order folios. This provides a direct opt-in mechanism for a subsystem, and it allows subsystems that can track low- and high- order objects independently to efficiently free objects in a way that will help improve compaction rates without impacting the entire working set of objects in the cache.

IOWs, this patch to inform kswapd about it's trigger (doesn't it already have a "reason" parameter, though?) is likely a necessary part of the solution - we don't want kswapd running shrinkers if it has been triggered to reclaim pages for compaction. This patch would allows kswapd to elide normal shrinker passes when it has been woken purely for compaction purposes. Given that the compaction code would be running the high-order reclaim capable shrinkers itself, this would avoid trashing the working set of most shrinkable caches -by default- under high order allocation demand....

-Dave.

Signature · 2 lines
Dave Chinner
[email protected]
author maintainer
#4 lore raw

Re: [PATCH v6 1/2] mm: Introduce opportunistic_compaction concept to vmscan and shrinkers

Quoted 15 lines · Dave Chinner
Quoted 14 lines · Matthew Brost

High-order allocations using __GFP_NORETRY or __GFP_RETRY_MAYFAIL are often opportunistic attempts to satisfy fragmentation-sensitive allocations rather than indications of severe memory pressure. In these cases, reclaim may invoke shrinkers that aggressively destroy working sets even though reclaim is unlikely to materially improve the allocation outcome.

Some shrinkers manage expensive backing or migration operations where reclaim can result in substantial working set disruption despite the system having sufficient free memory overall. This is particularly visible in fragmentation-heavy workloads where reclaim repeatedly tears down active state while kswapd attempts to satisfy higher-order allocations.

Quoted 6 lines
Quoted 6 lines

Introduce an opportunistic_compaction hint in shrink_control that allows kswapd to communicate when reclaim originates from a high-order allocation context that may be fragmentation driven rather than true memory pressure. Shrinkers may use this hint to avoid destructive working set reclaim while still participating normally during order-0 or stronger reclaim conditions.

Thanks for the input - this is a tough problem.

Quoted 6 lines

To be honest, this seems like another "push a hint through to the XE shrinker" mechanism under a different name. You seem so focused on fixing the XE reproducer that the -systemic problem- that -any- high-order folio demand causes is not being acknowleged.

I'm not exactly sure I agree here. Communicating via __GFP_NORETRY or __GFP_RETRY_MAYFAIL with a higher order implies that the caller can handle higher-order allocation failures, so the shrinker shouldn’t try too hard to obtain a large page (e.g., evict a working set). I agree that Xe is currently the only shrinker making use of this, but other shrinkers could also hook into it. This information simply isn’t available today.

Quoted 6 lines

e.g. we use high-order folios extensively in the page cache these days, and there are -many- cases where memory compaction driven by high-order demand cause significant performance regressions for page cache performance. To date, every single person who has wanted to fix the problem they are seeing has effectively attempted to -turn off compaction- via GFP flags.

So does that mean they clear __GFP_RECLAIM?

That isn't really what in DRM or Xe. In former case we have pools of lower order pages in TTM not in use that can be shrunk, potentially freeing multiple lower orders pages so a higher order page formed, and the later possible BOs (sets of pages) in Xe marked as purgable (not is in working set) which can also be shrunk. Other DRM drivers have purging concepts too.

I’m not very familiar with what other shrinkers or subsystems want, but presumably other shrinkers have pools or caches that aren’t currently in use, where they can say, “OK, I’ll give these pages up for opportunistic compaction, but I won’t give up my working set.” Of course, as mentioned above, if someone else explicitly requests large pages by avoiding __GFP_NORETRY and __GFP_RETRY_MAYFAIL, the shrinker should then give up its working set.

Quoted 15 lines

I've even done that myself inside XFS to work around kvmalloc() issues with a lack of GFP_NOFAIL support and doing costly high order allocations that fail and trigger compaction before falling back to vmalloc(). However, these issues have since been fixed in the kvmalloc() code, such that it now does the right thing for most calling contexts (i.e. tries high-order kmalloc() without triggering compaction, then fall back to GFP_NOFAIL vmalloc()). This has made kvmalloc() more performant and better behaved for -all users-, not just XFS.

This is not sustainable - we need compaction to be robust and performant in the face of high-order folio demands, regardless of what subsystem is generating the demand.

Quoted 7 lines

So with that in mind, let me paraphrase the comment in the second patch in the Xe shrinker implementation:

"Shrinker reclaim is based on implementation specific object sizes so it is unlikely to ever acheive contiguous page reclaim in a manner that will measurably improve compaction rates."

This might be slightly misworded—what I really mean is that I don’t want to give up my working set for higher-order allocations that are allowed to fail, but I do want to give up my cache.

Quoted 9 lines

You also say:

Quoted 1 line

No functional changes are introduced for existing shrinkers.

Consider how many shrinkable caches the general statement above applies to, and then think about the fundamental impedence mismatch between the affected shrinkable caches and what this patch actually fixes.

Yes, as mentioned above, I’m only addressing Xe here, and I agree that this is likely an issue. Do you know of other shrinkers that have pools or caches which can be shrunk under the conditions I’m introducing here, but also have a working set they would prefer not to give up? If so, a link on elixir.bootlin.com would be helpful so I can take a look. I’ll also try to go through other shrinkers myself.

Quoted 9 lines

For example, what happens to slab-based caches if the XE cache is being excessively reclaimed under high-order page demand? e.g. the slab-based cache may have tens of objects per page and holds a system-level performance critical working set of objects. How do these caches handle the excessive reclaim demand being generated by compaction thrashing?

Yup, they don't.

Agree.

Quoted 10 lines

In the case of filesystem caches, the "reclaim and repopulate" pattern you describe causing the XE perf problems causes internal slab cache fragmentation. Not only does this not improve compaction rates, it also results in more memory fragmentation because slab pages get pinned by a small number of long lived objects and they won't get freed until the cache is largely emptied. IOWs, things get -even worse- from a memory fragmentation POV when compaction thrashing causes the working set of a high-object-count-per-page slab cache to thrash....

Got a link to the code which you are referring to?

That seems like a problem similar to another issue in DRM/Xe. We found that the process of shrinking actually drove fragmentation by splitting folios down to order-0 and then backing pages up one at a time. I have a separate fix in flight for that.

Could the filesystem detect these hints and avoid shrinking in a way that causes fragmentation? Alternatively, could it perform shrinking in a way that doesn’t shatter folios, or detect long-lived objects so it understands that shrinking isn’t going to help reduce fragmentation?

Quoted 2 lines

This isn't isolated to individual subsystem thrashing. If we run a file-based workload that generates high-order folio demand and hence

What GFP flags are typical used for file-based workloads?

Quoted 5 lines

compaction (e.g copy tens of GB of files between two XFS, ext4 or btrfs filesystems), that will -also- trash the Xe working set via the shrinker being hammered by memory compaction try to free up contiguous pages for the page cache.

I could see this.

Quoted 4 lines

Similarly, if we run a Xe workload that generates sustained high order folio demand, that will trash the working set in the dentry and inode caches and any other shrinkable slab-based cache.

I could also see this but DRM / Xe will set __GFP_NORETRY or __GFP_RETRY_MAYFAIL on higer-orders so those caches should be able to not trash its working set if looked for this hint.

Quoted 8 lines

Hence the abstracted case of the problem we need to solve is this:
shrinker reclaim is based on x-byte objects is extremely unlikely to acheive contiguous page reclaim in a manner that will measurably improve compaction rates.

This is a problem that has to be addresses by the high level infrastructure level, not worked around by individual shrinkers.

Quoted 7 lines

IMO, compaction shouldn't trigger shrinkers unless the shrinkers are specifically flagged as being able to release contiguous pages of memory in short order. I don't think there's very many shrinkable caches that even hold a significant quantity of objects larger than a single page, so it's clearly questionable as to whether compaction based reclaim should run shrinker reclaim to begin with.

Yes, sort of do this in Xe by changing '->count_objects' based on the hint.

Quoted 3 lines

i.e. a subsystem that can track high order folios in a shrinkable cache should probably have a "->compaction_scan()" method that is run directly from compaction context to try to free high order

When you say “compaction context,” which parts of the code are you referring to? I’d like to explore this option, but I need a bit more context.

Quoted 5 lines

folios. This provides a direct opt-in mechanism for a subsystem, and it allows subsystems that can track low- and high- order objects independently to efficiently free objects in a way that will help improve compaction rates without impacting the entire working set of objects in the cache.

Does this help if, for example, the cache is holding onto two order-8 folios that could be freed and merged, while the caller really wants an order-9 folio? This seems like a possible scenario in caches and is certainly true in TTM pools.

Quoted 11 lines

IOWs, this patch to inform kswapd about it's trigger (doesn't it already have a "reason" parameter, though?) is likely a necessary part of the solution - we don't want kswapd running shrinkers if it has been triggered to reclaim pages for compaction. This patch would allows kswapd to elide normal shrinker passes when it has been woken purely for compaction purposes. Given that the compaction code would be running the high-order reclaim capable shrinkers itself, this would avoid trashing the working set of most shrinkable caches -by default- under high order allocation demand....

I’m trying to parse this—are you suggesting that, one way or another, we introduce a heuristic where shrinkers can act on a hint (whether it’s what I have here or a new ->compaction_scan() vfunc), and then attempt to fix all shrinkers in this series? I’m open to trying to fix other shrinkers as well. Do you have any particular ones in mind? I count around 45 shrinkers in Linux, so it’s unlikely I can fix every single one, though or all shrinkers need to be fixed.

On a side note, I just noticed that struct shrinker has count_objects and scan_objects as individual vfuncs rather than using a const struct shrinker_ops *ops. Should we change that? The latter seems cleaner and is typically how things are done in Linux.

Matt

Quoted 4 lines

-Dave.

Signature · 2 lines
Dave Chinner
[email protected]
#5 lore raw

Re: [PATCH v6 1/2] mm: Introduce opportunistic_compaction concept to vmscan and shrinkers

Quoted 16 lines · Matthew Brost
Quoted 15 lines · Dave Chinner
Quoted 14 lines · Matthew Brost

High-order allocations using __GFP_NORETRY or __GFP_RETRY_MAYFAIL are often opportunistic attempts to satisfy fragmentation-sensitive allocations rather than indications of severe memory pressure. In these cases, reclaim may invoke shrinkers that aggressively destroy working sets even though reclaim is unlikely to materially improve the allocation outcome.

Some shrinkers manage expensive backing or migration operations where reclaim can result in substantial working set disruption despite the system having sufficient free memory overall. This is particularly visible in fragmentation-heavy workloads where reclaim repeatedly tears down active state while kswapd attempts to satisfy higher-order allocations.

Quoted 8 lines
Quoted 6 lines
Quoted 6 lines

Introduce an opportunistic_compaction hint in shrink_control that allows kswapd to communicate when reclaim originates from a high-order allocation context that may be fragmentation driven rather than true memory pressure. Shrinkers may use this hint to avoid destructive working set reclaim while still participating normally during order-0 or stronger reclaim conditions.

Thanks for the input - this is a tough problem.

Yes, that it is.

Quoted 6 lines
Quoted 5 lines

To be honest, this seems like another "push a hint through to the XE shrinker" mechanism under a different name. You seem so focused on fixing the XE reproducer that the -systemic problem- that -any- high-order folio demand causes is not being acknowleged.

Quoted 7 lines

I'm not exactly sure I agree here. Communicating via __GFP_NORETRY or __GFP_RETRY_MAYFAIL with a higher order implies that the caller can handle higher-order allocation failures, so the shrinker shouldn’t try too hard to obtain a large page (e.g., evict a working set). I agree that Xe is currently the only shrinker making use of this, but other shrinkers could also hook into it. This information simply isn’t available today.

Right, but "we are doing compaction" isn't information that tells the subsystem shrinker what it needs to do. "memory compaction is occurring" isn't a well defined action like "count reclaimable objects" or "scan N objects and reclaim as many as you can without blocking".

Directed high order object reclaim should be much efficient that trying to use general memory pressure to age out enough objects to reform contiguous pages. We need to help memory compaction, and we can't really do that by layering heuristics over reclaim algorithms designed to maintain working sets efficiently.

Quoted 8 lines
Quoted 6 lines

e.g. we use high-order folios extensively in the page cache these days, and there are -many- cases where memory compaction driven by high-order demand cause significant performance regressions for page cache performance. To date, every single person who has wanted to fix the problem they are seeing has effectively attempted to -turn off compaction- via GFP flags.

So does that mean they clear __GFP_RECLAIM?

Usually __GFP_DIRECT_RECLAIM, as it's the overhead of direct compaction that causes the performance problems.

Quoted 7 lines

That isn't really what in DRM or Xe. In former case we have pools of lower order pages in TTM not in use that can be shrunk, potentially freeing multiple lower orders pages so a higher order page formed, and the later possible BOs (sets of pages) in Xe marked as purgable (not is in working set) which can also be shrunk. Other DRM drivers have purging concepts too.

Quoted 7 lines

I’m not very familiar with what other shrinkers or subsystems want, but presumably other shrinkers have pools or caches that aren’t currently in use, where they can say, “OK, I’ll give these pages up for opportunistic compaction, but I won’t give up my working set.” Of course, as mentioned above, if someone else explicitly requests large pages by avoiding __GFP_NORETRY and __GFP_RETRY_MAYFAIL, the shrinker should then give up its working set.

Most caches are slab-based, so there can be 10s of objects with different life cycles per page. There is no almost possiblity that shrinker reclaim will free pages without substantial amounts of the cache being reclaimed.

Quoted 17 lines
Quoted 17 lines

I've even done that myself inside XFS to work around kvmalloc() issues with a lack of GFP_NOFAIL support and doing costly high order allocations that fail and trigger compaction before falling back to vmalloc(). However, these issues have since been fixed in the kvmalloc() code, such that it now does the right thing for most calling contexts (i.e. tries high-order kmalloc() without triggering compaction, then fall back to GFP_NOFAIL vmalloc()). This has made kvmalloc() more performant and better behaved for -all users-, not just XFS.

This is not sustainable - we need compaction to be robust and performant in the face of high-order folio demands, regardless of what subsystem is generating the demand.

So with that in mind, let me paraphrase the comment in the second patch in the Xe shrinker implementation:

Quoted 8 lines
Quoted 4 lines

"Shrinker reclaim is based on implementation specific object sizes so it is unlikely to ever acheive contiguous page reclaim in a manner that will measurably improve compaction rates."

This might be slightly misworded—what I really mean is that I don’t want to give up my working set for higher-order allocations that are allowed to fail, but I do want to give up my cache.

Right, that's the core of the problem - compaction is the high-order reclaim trigger, the existing shrinker infrastructure reclaim is for the working-set maintenance reclaim algorithm the subsystem uses..

Quoted 10 lines
Quoted 9 lines

You also say:

Quoted 1 line

No functional changes are introduced for existing shrinkers.

Consider how many shrinkable caches the general statement above applies to, and then think about the fundamental impedence mismatch between the affected shrinkable caches and what this patch actually fixes.

Quoted 4 lines

Yes, as mentioned above, I’m only addressing Xe here, and I agree that this is likely an issue. Do you know of other shrinkers that have pools or caches which can be shrunk under the conditions I’m introducing here, but also have a working set they would prefer not to give up?

The first that comes to mind is the xfs_buf cache. This cache holds cached metadata buffers that have different sizes can each contain up 64kB of contiguous pages. The allocation algorithm uses optimisitic large folios allocation, but if that fails it falls back to vmalloc. The working set is maintained by a prioritised multi-scan LRU so that more frequently accessed metadata is held tighter by the cache than less frequently accessed (e.g. btree roots have higher retention priority than the lowest leaves).

It does not currently track buffer objects by size, by if there was a benefit to doing so then it could be implemented. I'd much prefer to have such tracking separate to the working set maintenance, especially as they will likely need some kind of balancing to prevent high-order buffers in the working set from being thrashed by compaction demand....

I know there are other caches that have variable sized objects, but I'd have to go look at the code to referesh my memory of which ones they are...

Quoted 3 lines

If so, a
link on elixir.bootlin.com would be helpful so I can take a look. I’ll also try to go through other shrinkers myself.

cscope is your friend.

fs/xfs/xfs_buf.c contains the XFS buffer cache and shrinker infrastructure, but looking at the code without any understanding of the filesystem structures or how it interacts with the other XFS shrinkable caches probably isn't as useful as you might think it will be.

Quoted 23 lines
Quoted 9 lines

For example, what happens to slab-based caches if the XE cache is being excessively reclaimed under high-order page demand? e.g. the slab-based cache may have tens of objects per page and holds a system-level performance critical working set of objects. How do these caches handle the excessive reclaim demand being generated by compaction thrashing?

Yup, they don't.

Agree.

Quoted 10 lines

In the case of filesystem caches, the "reclaim and repopulate" pattern you describe causing the XE perf problems causes internal slab cache fragmentation. Not only does this not improve compaction rates, it also results in more memory fragmentation because slab pages get pinned by a small number of long lived objects and they won't get freed until the cache is largely emptied. IOWs, things get -even worse- from a memory fragmentation POV when compaction thrashing causes the working set of a high-object-count-per-page slab cache to thrash....

Quoted 1 line

Got a link to the code which you are referring to?

Do a lore search for "dentry cache defragmentation". You should be able to find discussions that go back to around 2006 about discussions on identry cache fragmentation and approaches like slab-page based object reclaim to support internal defragmentation.

The fact that we don't have slab cache defragmentation despite many years of people wanting such functionality should tell you how complex the problem is.... :/

Quoted 4 lines

That seems like a problem similar to another issue in DRM/Xe. We found that the process of shrinking actually drove fragmentation by splitting folios down to order-0 and then backing pages up one at a time. I have a separate fix in flight for that.

Possibly, though the life cycle differences I'm talking about can be a few milliseconds (temporary file) vs weeks (long running database instance holding it's table files open the whole time it is running).

Quoted 2 lines

Could the filesystem detect these hints and avoid shrinking in a way that causes fragmentation?

Not really. The fragmentation problem is caused by physical object placement in the slab pages at allocation time, not the act of reclaiming the object.

i.e. we don't know what the expected cache life time of a dentry or an inode will be when we allocate it, so it just gets allocated in the next free slot in the current partial slab page. When you get a mix of dentries that are pinned by open files in long running applications and dentries for access-once files in the same page, we end up with reclaim freeing all the object slots that contained access-once files. However, the pages are still pinned by the objects for the open files that are in active use.

IOWs, LRU-based reclaim can free >90% of the objects in a cache that held millions of objects with mixed lifetimes and still not free any memory at all. There's nothing reclaim can do about it because the problem is created at allocation time when lifetime is a complete unknown.

Quoted 3 lines

Alternatively, could it perform shrinking in
a way that doesn’t shatter folios, or detect long-lived objects so it understands that shrinking isn’t going to help reduce fragmentation?

Referenced filesystem objects are not on the LRUs, so the shrinkers aren't even aware of such long lived objects. And, as per the "dentry cache defrag" comment above, we can't ask the slab to reclaim or move objects because we don't track the owners of external references to the objects themselves.

Quoted 5 lines
Quoted 3 lines

This isn't isolated to individual subsystem thrashing. If we run a file-based workload that generates high-order folio demand and hence

What GFP flags are typical used for file-based workloads?

Mostly GFP_KERNEL, with a mix of GFP_NOFS. non-blocking paths also tend to add GFP_NOWAITS, and memory reclaim sensitive paths often use __GFP_MEMALLOC to prevent reclaim recursion. Some filesystems also make extensive use of GFP_NOFAIL (e.g. XFS).

Quoted 8 lines
Quoted 5 lines

compaction (e.g copy tens of GB of files between two XFS, ext4 or btrfs filesystems), that will -also- trash the Xe working set via the shrinker being hammered by memory compaction try to free up contiguous pages for the page cache.

I could see this.

Quoted 8 lines
Quoted 4 lines

Similarly, if we run a Xe workload that generates sustained high order folio demand, that will trash the working set in the dentry and inode caches and any other shrinkable slab-based cache.

I could also see this but DRM / Xe will set __GFP_NORETRY or __GFP_RETRY_MAYFAIL on higer-orders so those caches should be able to not trash its working set if looked for this hint.

This relies on all the allocation code everywhere always doing exactly the right thing so that memory reclaim "behaves". That is what I've been saying is not a sustainable approach - all it takes is one allocation or one shrinker not to do the right thing, and we've got another mole to whack. i.e. memory allocation should do the right/best thing for the system with default parameters.

Quoted 16 lines
Quoted 8 lines

Hence the abstracted case of the problem we need to solve is this:
shrinker reclaim is based on x-byte objects is extremely unlikely to acheive contiguous page reclaim in a manner that will measurably improve compaction rates.

This is a problem that has to be addresses by the high level infrastructure level, not worked around by individual shrinkers.

Quoted 7 lines

IMO, compaction shouldn't trigger shrinkers unless the shrinkers are specifically flagged as being able to release contiguous pages of memory in short order. I don't think there's very many shrinkable caches that even hold a significant quantity of objects larger than a single page, so it's clearly questionable as to whether compaction based reclaim should run shrinker reclaim to begin with.

Quoted 2 lines

Yes, sort of do this in Xe by changing '->count_objects' based on the hint.

I know. That's the problem - it's relying on the infrastructure passing down a specific internal context hint in an existing interface so a specific subsystem can work around a specific problematic behaviour.

Indeed, for compaction we don't actually care about the count, what we largely care about is whether the subsystem has any objects the same size or larger than the current compaction demand. Efficient object reclaim for compaction has a different control variable set (e.g. find objects larger than, objects physically near to, etc), and this can't really be properly fitted into the existing count/scan shrinker reclaim algorithm.

Hence I think it needs new shrinker methods to implement effectively.

Quoted 7 lines
Quoted 3 lines

i.e. a subsystem that can track high order folios in a shrinkable cache should probably have a "->compaction_scan()" method that is run directly from compaction context to try to free high order

When you say “compaction context,” which parts of the code are you referring to? I’d like to explore this option, but I need a bit more context.

kcompactd does background compaction, similar to how we have kswapd to do background memory reclaim.

Direct compaction (part of direct reclaim) via __alloc_pages_direct_compact() that will be called before direct memory reclaim in the case of a high-order allocation.

Quoted 8 lines
Quoted 6 lines

folios. This provides a direct opt-in mechanism for a subsystem, and it allows subsystems that can track low- and high- order objects independently to efficiently free objects in a way that will help improve compaction rates without impacting the entire working set of objects in the cache.

Quoted 4 lines

Does this help if, for example, the cache is holding onto two order-8 folios that could be freed and merged, while the caller really wants an order-9 folio? This seems like a possible scenario in caches and is certainly true in TTM pools.

Depends on how the interface is implemented.

IIUC, the direct compaction code will return a right-sized page early if it creates one via compact_zone(). Hence if that path can call into shrinkers to do high-order scanning that results in two mergable order-8 objects being freed and merged into an order-9 object that fulfils the compaction requirements, then it will result in compaction succeeding where it currently fails.

And I think that kcompactd will run until certain watermarks are met, so again having a high-order shrinker that directly impacts the high order page watermarks would be much more efficient that trying to use general memory pressure to randomly shoot down enough objects to reform contiguous pages.

Quoted 11 lines
Quoted 10 lines

IOWs, this patch to inform kswapd about it's trigger (doesn't it already have a "reason" parameter, though?) is likely a necessary part of the solution - we don't want kswapd running shrinkers if it has been triggered to reclaim pages for compaction. This patch would allows kswapd to elide normal shrinker passes when it has been woken purely for compaction purposes. Given that the compaction code would be running the high-order reclaim capable shrinkers itself, this would avoid trashing the working set of most shrinkable caches -by default- under high order allocation demand....

Quoted 4 lines

I’m trying to parse this—are you suggesting that, one way or another, we introduce a heuristic where shrinkers can act on a hint (whether it’s what I have here or a new ->compaction_scan() vfunc), and then attempt to fix all shrinkers in this series?

I don't want existing shrinkers to be touched at all.

What I want is for memory reclaim (both direct and kswapd) to elide the shrink_slab() calls into shrinkers when memory reclaim is being driven by high order allocation failure.

i.e. high-order allocation failure should not generate shrinkable cache memory pressure because shrinkable caches in general cannot return contiguous memory that will allows compaction to make progress. The existing behaviour has more negative affects on system performance than positive, so we need a fix for "everyone".

I think we should provide a new opt-in ->compaction_scan() method for compaction aware subsystem shrinkers that is run from compact_zone() context. This allows subsystems that can manage high order objects to optimise the return of high order objects to the free space pool, thereby significantly improving the chance for compaction to succeed without adversely impacting the rest of the shrinkable caches in the system.

Further, we should not kick kswapd because of compaction failures because kcompactd will already be running ->compaction_scan() capable shrinkers from it's callouts to compact_zone() in the background that will do this work as efficiently as possible.

Quoted 4 lines

I’m open to trying to fix other
shrinkers as well. Do you have any particular ones in mind? I count around 45 shrinkers in Linux, so it’s unlikely I can fix every single one, though or all shrinkers need to be fixed.

They'd all need to be fixed, which is why I suggested a new method to be added. Avoid calling the existing shrinkers in the adverse situation, call the new one from the right context where it actually benefits compaction and high-order memory allocation.

Quoted 4 lines

On a side note, I just noticed that struct shrinker has count_objects and scan_objects as individual vfuncs rather than using a const struct shrinker_ops *ops. Should we change that? The latter seems cleaner and is typically how things are done in Linux.

We probably should - the current structure is largely historical and there's only ever been two methods. If we are adding another method, then it would probably make sense to add an external ops structure to reduce the memory footprint a little.

-Dave.

Signature · 2 lines
Dave Chinner
[email protected]
author maintainer
#6 lore raw

Re: [PATCH v6 1/2] mm: Introduce opportunistic_compaction concept to vmscan and shrinkers

Quoted 24 lines · Dave Chinner
Quoted 23 lines · Matthew Brost
Quoted 21 lines · Dave Chinner
Quoted 20 lines · Matthew Brost

High-order allocations using __GFP_NORETRY or __GFP_RETRY_MAYFAIL are often opportunistic attempts to satisfy fragmentation-sensitive allocations rather than indications of severe memory pressure. In these cases, reclaim may invoke shrinkers that aggressively destroy working sets even though reclaim is unlikely to materially improve the allocation outcome.

Some shrinkers manage expensive backing or migration operations where reclaim can result in substantial working set disruption despite the system having sufficient free memory overall. This is particularly visible in fragmentation-heavy workloads where reclaim repeatedly tears down active state while kswapd attempts to satisfy higher-order allocations.

Introduce an opportunistic_compaction hint in shrink_control that allows kswapd to communicate when reclaim originates from a high-order allocation context that may be fragmentation driven rather than true memory pressure. Shrinkers may use this hint to avoid destructive working set reclaim while still participating normally during order-0 or stronger reclaim conditions.

Quoted 4 lines
Quoted 1 line

Thanks for the input - this is a tough problem.

Yes, that it is.

This is part of what makes this fun.

There’s a lot to go through here—I’m going to start actively working on a PoC, hopefully today. I’ll likely have more feedback as this gets coded, but let’s continue to stay aligned.

Quoted 53 lines
Quoted 6 lines
Quoted 5 lines

To be honest, this seems like another "push a hint through to the XE shrinker" mechanism under a different name. You seem so focused on fixing the XE reproducer that the -systemic problem- that -any- high-order folio demand causes is not being acknowleged.

Quoted 7 lines

I'm not exactly sure I agree here. Communicating via __GFP_NORETRY or __GFP_RETRY_MAYFAIL with a higher order implies that the caller can handle higher-order allocation failures, so the shrinker shouldn’t try too hard to obtain a large page (e.g., evict a working set). I agree that Xe is currently the only shrinker making use of this, but other shrinkers could also hook into it. This information simply isn’t available today.

Right, but "we are doing compaction" isn't information that tells the subsystem shrinker what it needs to do. "memory compaction is occurring" isn't a well defined action like "count reclaimable objects" or "scan N objects and reclaim as many as you can without blocking".

Directed high order object reclaim should be much efficient that trying to use general memory pressure to age out enough objects to reform contiguous pages. We need to help memory compaction, and we can't really do that by layering heuristics over reclaim algorithms designed to maintain working sets efficiently.

Quoted 8 lines
Quoted 6 lines

e.g. we use high-order folios extensively in the page cache these days, and there are -many- cases where memory compaction driven by high-order demand cause significant performance regressions for page cache performance. To date, every single person who has wanted to fix the problem they are seeing has effectively attempted to -turn off compaction- via GFP flags.

So does that mean they clear __GFP_RECLAIM?

Usually __GFP_DIRECT_RECLAIM, as it's the overhead of direct compaction that causes the performance problems.

Quoted 7 lines

That isn't really what in DRM or Xe. In former case we have pools of lower order pages in TTM not in use that can be shrunk, potentially freeing multiple lower orders pages so a higher order page formed, and the later possible BOs (sets of pages) in Xe marked as purgable (not is in working set) which can also be shrunk. Other DRM drivers have purging concepts too.

Quoted 7 lines

I’m not very familiar with what other shrinkers or subsystems want, but presumably other shrinkers have pools or caches that aren’t currently in use, where they can say, “OK, I’ll give these pages up for opportunistic compaction, but I won’t give up my working set.” Of course, as mentioned above, if someone else explicitly requests large pages by avoiding __GFP_NORETRY and __GFP_RETRY_MAYFAIL, the shrinker should then give up its working set.

Quoted 4 lines

Most caches are slab-based, so there can be 10s of objects with different life cycles per page. There is no almost possiblity that shrinker reclaim will free pages without substantial amounts of the cache being reclaimed.

Yes, I agree most shrinkers are slab-based, but there are at least three notable exceptions that I’m aware of—potentially more (let me know if there are others which are aware of):

- The TTM (the most common memory allocator for DRM drivers) pool shrinker maintains pools of pages that are free (i.e., have no driver-side references).
- DRM driver-side shrinkers maintain both non-active pages (marked as purged by user space) and active pages that are either idle or short-term pinned via dma-fences.
- The deferred_split_shrinker, which holds pages in larger-order folios that have been partially unmapped.

All of these can free substantial amounts of memory—sometimes very quickly, and sometimes with a delay (e.g., when waiting on short-term pinned memory via dma-fences).

The deferred_split_shrinker in also seemingly has an issue where it can worsen fragmentation in certain cases. For example, if we need an order-9 folio and it shrinks a partially freed folio of the same or smaller order, this doesn’t help and may actively make fragmentation worse by shattering folios. While we’re here, this likely should be addressed—unless I’m missing something.

Quoted 23 lines
Quoted 23 lines
Quoted 22 lines

I've even done that myself inside XFS to work around kvmalloc() issues with a lack of GFP_NOFAIL support and doing costly high order allocations that fail and trigger compaction before falling back to vmalloc(). However, these issues have since been fixed in the kvmalloc() code, such that it now does the right thing for most calling contexts (i.e. tries high-order kmalloc() without triggering compaction, then fall back to GFP_NOFAIL vmalloc()). This has made kvmalloc() more performant and better behaved for -all users-, not just XFS.

This is not sustainable - we need compaction to be robust and performant in the face of high-order folio demands, regardless of what subsystem is generating the demand.

So with that in mind, let me paraphrase the comment in the second patch in the Xe shrinker implementation:

"Shrinker reclaim is based on implementation specific object sizes so it is unlikely to ever acheive contiguous page reclaim in a manner that will measurably improve compaction rates."

Quoted 8 lines
Quoted 3 lines

This might be slightly misworded—what I really mean is that I don’t want to give up my working set for higher-order allocations that are allowed to fail, but I do want to give up my cache.

Right, that's the core of the problem - compaction is the high-order reclaim trigger, the existing shrinker infrastructure reclaim is for the working-set maintenance reclaim algorithm the subsystem uses..

Ok. We also need to consider how direct reclaim and compaction interact. Shrinkers are currently invoked during direct reclaim, which I believe is correct—this helps with compaction and is desirable. More on this below.

Quoted 31 lines
Quoted 10 lines
Quoted 9 lines

You also say:

Quoted 1 line

No functional changes are introduced for existing shrinkers.

Consider how many shrinkable caches the general statement above applies to, and then think about the fundamental impedence mismatch between the affected shrinkable caches and what this patch actually fixes.

Quoted 4 lines

Yes, as mentioned above, I’m only addressing Xe here, and I agree that this is likely an issue. Do you know of other shrinkers that have pools or caches which can be shrunk under the conditions I’m introducing here, but also have a working set they would prefer not to give up?

The first that comes to mind is the xfs_buf cache. This cache holds cached metadata buffers that have different sizes can each contain up 64kB of contiguous pages. The allocation algorithm uses optimisitic large folios allocation, but if that fails it falls back to vmalloc. The working set is maintained by a prioritised multi-scan LRU so that more frequently accessed metadata is held tighter by the cache than less frequently accessed (e.g. btree roots have higher retention priority than the lowest leaves).

It does not currently track buffer objects by size, by if there was a benefit to doing so then it could be implemented. I'd much prefer to have such tracking separate to the working set maintenance, especially as they will likely need some kind of balancing to prevent high-order buffers in the working set from being thrashed by compaction demand....

Quoted 4 lines

I know there are other caches that have variable sized objects, but I'd have to go look at the code to referesh my memory of which ones they are...

I'll have to look more here to be able to respond intelligently.

Quoted 11 lines
Quoted 3 lines

If so, a
link on elixir.bootlin.com would be helpful so I can take a look. I’ll also try to go through other shrinkers myself.

cscope is your friend.

fs/xfs/xfs_buf.c contains the XFS buffer cache and shrinker infrastructure, but looking at the code without any understanding of the filesystem structures or how it interacts with the other XFS shrinkable caches probably isn't as useful as you might think it will be.

Agree. Looked at some FS shrinkers and got lost quickly.

Quoted 101 lines
Quoted 24 lines
Quoted 10 lines

For example, what happens to slab-based caches if the XE cache is being excessively reclaimed under high-order page demand? e.g. the slab-based cache may have tens of objects per page and holds a system-level performance critical working set of objects. How do these caches handle the excessive reclaim demand being generated by compaction thrashing?

Yup, they don't.

Agree.

Quoted 10 lines

In the case of filesystem caches, the "reclaim and repopulate" pattern you describe causing the XE perf problems causes internal slab cache fragmentation. Not only does this not improve compaction rates, it also results in more memory fragmentation because slab pages get pinned by a small number of long lived objects and they won't get freed until the cache is largely emptied. IOWs, things get -even worse- from a memory fragmentation POV when compaction thrashing causes the working set of a high-object-count-per-page slab cache to thrash....

Quoted 1 line

Got a link to the code which you are referring to?

Do a lore search for "dentry cache defragmentation". You should be able to find discussions that go back to around 2006 about discussions on identry cache fragmentation and approaches like slab-page based object reclaim to support internal defragmentation.

The fact that we don't have slab cache defragmentation despite many years of people wanting such functionality should tell you how complex the problem is.... :/

Quoted 4 lines

That seems like a problem similar to another issue in DRM/Xe. We found that the process of shrinking actually drove fragmentation by splitting folios down to order-0 and then backing pages up one at a time. I have a separate fix in flight for that.

Possibly, though the life cycle differences I'm talking about can be a few milliseconds (temporary file) vs weeks (long running database instance holding it's table files open the whole time it is running).

Quoted 2 lines

Could the filesystem detect these hints and avoid shrinking in a way that causes fragmentation?

Not really. The fragmentation problem is caused by physical object placement in the slab pages at allocation time, not the act of reclaiming the object.

i.e. we don't know what the expected cache life time of a dentry or an inode will be when we allocate it, so it just gets allocated in the next free slot in the current partial slab page. When you get a mix of dentries that are pinned by open files in long running applications and dentries for access-once files in the same page, we end up with reclaim freeing all the object slots that contained access-once files. However, the pages are still pinned by the objects for the open files that are in active use.

IOWs, LRU-based reclaim can free >90% of the objects in a cache that held millions of objects with mixed lifetimes and still not free any memory at all. There's nothing reclaim can do about it because the problem is created at allocation time when lifetime is a complete unknown.

Quoted 3 lines

Alternatively, could it perform shrinking in
a way that doesn’t shatter folios, or detect long-lived objects so it understands that shrinking isn’t going to help reduce fragmentation?

Referenced filesystem objects are not on the LRUs, so the shrinkers aren't even aware of such long lived objects. And, as per the "dentry cache defrag" comment above, we can't ask the slab to reclaim or move objects because we don't track the owners of external references to the objects themselves.

Quoted 5 lines
Quoted 3 lines

This isn't isolated to individual subsystem thrashing. If we run a file-based workload that generates high-order folio demand and hence

What GFP flags are typical used for file-based workloads?

Mostly GFP_KERNEL, with a mix of GFP_NOFS. non-blocking paths also tend to add GFP_NOWAITS, and memory reclaim sensitive paths often use __GFP_MEMALLOC to prevent reclaim recursion. Some filesystems also make extensive use of GFP_NOFAIL (e.g. XFS).

Quoted 13 lines
Quoted 5 lines

compaction (e.g copy tens of GB of files between two XFS, ext4 or btrfs filesystems), that will -also- trash the Xe working set via the shrinker being hammered by memory compaction try to free up contiguous pages for the page cache.

I could see this.

Quoted 4 lines

Similarly, if we run a Xe workload that generates sustained high order folio demand, that will trash the working set in the dentry and inode caches and any other shrinkable slab-based cache.

Quoted 6 lines
Quoted 3 lines

I could also see this but DRM / Xe will set __GFP_NORETRY or __GFP_RETRY_MAYFAIL on higer-orders so those caches should be able to not trash its working set if looked for this hint.

This relies on all the allocation code everywhere always doing exactly the right thing so that memory reclaim "behaves". That is

Yes and no. The original issue was a DRM/TTM self-feedback loop, where we need some shrinking/reclaim, but not all. In general, this feedback loop also occurs on CPU/GPU client paths, so running XPS alongside heavy DRM/TTM with a client part is a very unlikely use case.

Quoted 5 lines

what I've been saying is not a sustainable approach - all it takes is one allocation or one shrinker not to do the right thing, and we've got another mole to whack. i.e. memory allocation should do the right/best thing for the system with default parameters.

I agree that another allocation could shrink DRM/TTM buffers, but when DRM/TTM reallocates, it won’t trigger the same feedback loop since it uses the correct GFP flags. While it’s true that two conflicting allocations can ping-pong, we are also working on a DRM/TTM reclaim backoff mechanism and a defragmenter. However, if a self-feedback loop exists, this effort becomes ineffective.

Quoted 32 lines
Quoted 16 lines
Quoted 8 lines

Hence the abstracted case of the problem we need to solve is this:
shrinker reclaim is based on x-byte objects is extremely unlikely to acheive contiguous page reclaim in a manner that will measurably improve compaction rates.

This is a problem that has to be addresses by the high level infrastructure level, not worked around by individual shrinkers.

Quoted 7 lines

IMO, compaction shouldn't trigger shrinkers unless the shrinkers are specifically flagged as being able to release contiguous pages of memory in short order. I don't think there's very many shrinkable caches that even hold a significant quantity of objects larger than a single page, so it's clearly questionable as to whether compaction based reclaim should run shrinker reclaim to begin with.

Quoted 2 lines

Yes, sort of do this in Xe by changing '->count_objects' based on the hint.

I know. That's the problem - it's relying on the infrastructure passing down a specific internal context hint in an existing interface so a specific subsystem can work around a specific problematic behaviour.

Indeed, for compaction we don't actually care about the count, what we largely care about is whether the subsystem has any objects the same size or larger than the current compaction demand. Efficient object reclaim for compaction has a different control variable set (e.g. find objects larger than, objects physically near to, etc), and this can't really be properly fitted into the existing count/scan shrinker reclaim algorithm.

Quoted 2 lines

Hence I think it needs new shrinker methods to implement effectively.

Looping back to direct reclaim above—would these new methods also be called during direct reclaim? My thinking is yes.

Quoted 5 lines
Quoted 5 lines
Quoted 4 lines

i.e. a subsystem that can track high order folios in a shrinkable cache should probably have a "->compaction_scan()" method that is run directly from compaction context to try to free high order

Quoted 7 lines
Quoted 3 lines

When you say “compaction context,” which parts of the code are you referring to? I’d like to explore this option, but I need a bit more context.

kcompactd does background compaction, similar to how we have kswapd to do background memory reclaim.

kcompactd doesn't call shrinkers - this is where we'd call compaction shrinkers?

Quoted 4 lines

Direct compaction (part of direct reclaim) via __alloc_pages_direct_compact() that will be called before direct memory reclaim in the case of a high-order allocation.

So maybe this is where compaction shrinkers fits in in direct reclaim?

Quoted 13 lines
Quoted 8 lines
Quoted 6 lines

folios. This provides a direct opt-in mechanism for a subsystem, and it allows subsystems that can track low- and high- order objects independently to efficiently free objects in a way that will help improve compaction rates without impacting the entire working set of objects in the cache.

Quoted 4 lines

Does this help if, for example, the cache is holding onto two order-8 folios that could be freed and merged, while the caller really wants an order-9 folio? This seems like a possible scenario in caches and is certainly true in TTM pools.

Quoted 9 lines

Depends on how the interface is implemented.

IIUC, the direct compaction code will return a right-sized page early if it creates one via compact_zone(). Hence if that path can call into shrinkers to do high-order scanning that results in two mergable order-8 objects being freed and merged into an order-9 object that fulfils the compaction requirements, then it will result in compaction succeeding where it currently fails.

I think this answers my question above - call compaction shrinker here.

Quoted 6 lines

And I think that kcompactd will run until certain watermarks are met, so again having a high-order shrinker that directly impacts the high order page watermarks would be much more efficient that trying to use general memory pressure to randomly shoot down enough objects to reform contiguous pages.

I think this answers my question above - call compaction shrinker here.

Quoted 16 lines
Quoted 11 lines
Quoted 10 lines

IOWs, this patch to inform kswapd about it's trigger (doesn't it already have a "reason" parameter, though?) is likely a necessary part of the solution - we don't want kswapd running shrinkers if it has been triggered to reclaim pages for compaction. This patch would allows kswapd to elide normal shrinker passes when it has been woken purely for compaction purposes. Given that the compaction code would be running the high-order reclaim capable shrinkers itself, this would avoid trashing the working set of most shrinkable caches -by default- under high order allocation demand....

Quoted 4 lines

I’m trying to parse this—are you suggesting that, one way or another, we introduce a heuristic where shrinkers can act on a hint (whether it’s what I have here or a new ->compaction_scan() vfunc), and then attempt to fix all shrinkers in this series?

Quoted 6 lines

I don't want existing shrinkers to be touched at all.

What I want is for memory reclaim (both direct and kswapd) to elide the shrink_slab() calls into shrinkers when memory reclaim is being driven by high order allocation failure.

I still think compaction shrinkers need a concept of “opportunistic” versus “must free memory to compact” to avoid the self-feedback loop I described. Without this, the DRM/TTM self-feedback loop would still exist.

Quoted 3 lines

i.e. high-order allocation failure should not generate shrinkable cache memory pressure because shrinkable caches in general cannot return contiguous memory that will allows compaction to make

Yes, I agree with “shrinkable caches in general,” aside from the exceptions I outlined above (though perhaps I’m missing other exceptions).

The risk of what you’re suggesting is that it would suddenly change the entire shrinking model across Linux, and we don’t know what unforeseen consequences this type of change might have. Nor could a single person reasonably test a change of this scope. That’s why an incremental step, like this series—which fixes DRM/TTM as opt-in—may make more sense. As mentioned above, the deferred_split_shrinker is also a very likely candidate for being fixed. That said, I’m going to look into your suggestion as well.

Quoted 5 lines

progress. The existing behaviour has more negative affects on system performance than positive, so we need a fix for "everyone".

I think we should provide a new opt-in ->compaction_scan() method for compaction aware subsystem shrinkers that is run from compact_zone()

compact_zone() appears to be called from both direct reclaim and kcompactd(), so perhaps some of the questions above are already answered.

Quoted 16 lines

context. This allows subsystems that can manage high order objects to optimise the return of high order objects to the free space pool, thereby significantly improving the chance for compaction to succeed without adversely impacting the rest of the shrinkable caches in the system.

Further, we should not kick kswapd because of compaction failures because kcompactd will already be running ->compaction_scan() capable shrinkers from it's callouts to compact_zone() in the background that will do this work as efficiently as possible.

Quoted 4 lines

I’m open to trying to fix other
shrinkers as well. Do you have any particular ones in mind? I count around 45 shrinkers in Linux, so it’s unlikely I can fix every single one, though or all shrinkers need to be fixed.

Quoted 5 lines

They'd all need to be fixed, which is why I suggested a new method to be added. Avoid calling the existing shrinkers in the adverse situation, call the new one from the right context where it actually benefits compaction and high-order memory allocation.

OK, this seems fairly reasonable on its surface despite my concerns above, but see my comment above regarding “opportunistic” vs. “must free memory to compact.” Without that distinction, I don’t think my original problem would be solved.

Given this scope / risks, can I ask for one of two things:

- We move ahead with this series as a stopgap fix, or
- Allow DRM/TTM/Xe to implement shrinker-side heuristics to break the feedback loop

while I work on this larger refactor. This is the type of work I enjoy doing, and I typically have the flexibility to work on what I think is most impactful.

Quoted 10 lines
Quoted 4 lines

On a side note, I just noticed that struct shrinker has count_objects and scan_objects as individual vfuncs rather than using a const struct shrinker_ops *ops. Should we change that? The latter seems cleaner and is typically how things are done in Linux.

We probably should - the current structure is largely historical and there's only ever been two methods. If we are adding another method, then it would probably make sense to add an external ops structure to reduce the memory footprint a little.

Let me look into this as well. I don’t know the exact merge flows for tree-wide changes, but I can figure it out.

Matt

Quoted 4 lines

-Dave.

Signature · 2 lines
Dave Chinner
[email protected]
author maintainer
#7 lore raw

Re: [PATCH v6 1/2] mm: Introduce opportunistic_compaction concept to vmscan and shrinkers

Quoted 420 lines · Matthew Brost
Quoted 24 lines · Dave Chinner
Quoted 23 lines · Matthew Brost
Quoted 21 lines · Dave Chinner
Quoted 20 lines · Matthew Brost

High-order allocations using __GFP_NORETRY or __GFP_RETRY_MAYFAIL are often opportunistic attempts to satisfy fragmentation-sensitive allocations rather than indications of severe memory pressure. In these cases, reclaim may invoke shrinkers that aggressively destroy working sets even though reclaim is unlikely to materially improve the allocation outcome.

Some shrinkers manage expensive backing or migration operations where reclaim can result in substantial working set disruption despite the system having sufficient free memory overall. This is particularly visible in fragmentation-heavy workloads where reclaim repeatedly tears down active state while kswapd attempts to satisfy higher-order allocations.

Introduce an opportunistic_compaction hint in shrink_control that allows kswapd to communicate when reclaim originates from a high-order allocation context that may be fragmentation driven rather than true memory pressure. Shrinkers may use this hint to avoid destructive working set reclaim while still participating normally during order-0 or stronger reclaim conditions.

Quoted 4 lines
Quoted 1 line

Thanks for the input - this is a tough problem.

Yes, that it is.

This is part of what makes this fun.

There’s a lot to go through here—I’m going to start actively working on a PoC, hopefully today. I’ll likely have more feedback as this gets coded, but let’s continue to stay aligned.

Quoted 53 lines
Quoted 6 lines
Quoted 5 lines

To be honest, this seems like another "push a hint through to the XE shrinker" mechanism under a different name. You seem so focused on fixing the XE reproducer that the -systemic problem- that -any- high-order folio demand causes is not being acknowleged.

Quoted 7 lines

I'm not exactly sure I agree here. Communicating via __GFP_NORETRY or __GFP_RETRY_MAYFAIL with a higher order implies that the caller can handle higher-order allocation failures, so the shrinker shouldn’t try too hard to obtain a large page (e.g., evict a working set). I agree that Xe is currently the only shrinker making use of this, but other shrinkers could also hook into it. This information simply isn’t available today.

Right, but "we are doing compaction" isn't information that tells the subsystem shrinker what it needs to do. "memory compaction is occurring" isn't a well defined action like "count reclaimable objects" or "scan N objects and reclaim as many as you can without blocking".

Directed high order object reclaim should be much efficient that trying to use general memory pressure to age out enough objects to reform contiguous pages. We need to help memory compaction, and we can't really do that by layering heuristics over reclaim algorithms designed to maintain working sets efficiently.

Quoted 8 lines
Quoted 6 lines

e.g. we use high-order folios extensively in the page cache these days, and there are -many- cases where memory compaction driven by high-order demand cause significant performance regressions for page cache performance. To date, every single person who has wanted to fix the problem they are seeing has effectively attempted to -turn off compaction- via GFP flags.

So does that mean they clear __GFP_RECLAIM?

Usually __GFP_DIRECT_RECLAIM, as it's the overhead of direct compaction that causes the performance problems.

Quoted 7 lines

That isn't really what in DRM or Xe. In former case we have pools of lower order pages in TTM not in use that can be shrunk, potentially freeing multiple lower orders pages so a higher order page formed, and the later possible BOs (sets of pages) in Xe marked as purgable (not is in working set) which can also be shrunk. Other DRM drivers have purging concepts too.

Quoted 7 lines

I’m not very familiar with what other shrinkers or subsystems want, but presumably other shrinkers have pools or caches that aren’t currently in use, where they can say, “OK, I’ll give these pages up for opportunistic compaction, but I won’t give up my working set.” Of course, as mentioned above, if someone else explicitly requests large pages by avoiding __GFP_NORETRY and __GFP_RETRY_MAYFAIL, the shrinker should then give up its working set.

Quoted 4 lines

Most caches are slab-based, so there can be 10s of objects with different life cycles per page. There is no almost possiblity that shrinker reclaim will free pages without substantial amounts of the cache being reclaimed.

Yes, I agree most shrinkers are slab-based, but there are at least three notable exceptions that I’m aware of—potentially more (let me know if there are others which are aware of):

- The TTM (the most common memory allocator for DRM drivers) pool shrinker maintains pools of pages that are free (i.e., have no driver-side references).
- DRM driver-side shrinkers maintain both non-active pages (marked as purged by user space) and active pages that are either idle or short-term pinned via dma-fences.
- The deferred_split_shrinker, which holds pages in larger-order folios that have been partially unmapped.

All of these can free substantial amounts of memory—sometimes very quickly, and sometimes with a delay (e.g., when waiting on short-term pinned memory via dma-fences).

The deferred_split_shrinker in also seemingly has an issue where it can worsen fragmentation in certain cases. For example, if we need an order-9 folio and it shrinks a partially freed folio of the same or smaller order, this doesn’t help and may actively make fragmentation worse by shattering folios. While we’re here, this likely should be addressed—unless I’m missing something.

Quoted 23 lines
Quoted 23 lines
Quoted 22 lines

I've even done that myself inside XFS to work around kvmalloc() issues with a lack of GFP_NOFAIL support and doing costly high order allocations that fail and trigger compaction before falling back to vmalloc(). However, these issues have since been fixed in the kvmalloc() code, such that it now does the right thing for most calling contexts (i.e. tries high-order kmalloc() without triggering compaction, then fall back to GFP_NOFAIL vmalloc()). This has made kvmalloc() more performant and better behaved for -all users-, not just XFS.

This is not sustainable - we need compaction to be robust and performant in the face of high-order folio demands, regardless of what subsystem is generating the demand.

So with that in mind, let me paraphrase the comment in the second patch in the Xe shrinker implementation:

"Shrinker reclaim is based on implementation specific object sizes so it is unlikely to ever acheive contiguous page reclaim in a manner that will measurably improve compaction rates."

Quoted 8 lines
Quoted 3 lines

This might be slightly misworded—what I really mean is that I don’t want to give up my working set for higher-order allocations that are allowed to fail, but I do want to give up my cache.

Right, that's the core of the problem - compaction is the high-order reclaim trigger, the existing shrinker infrastructure reclaim is for the working-set maintenance reclaim algorithm the subsystem uses..

Ok. We also need to consider how direct reclaim and compaction interact. Shrinkers are currently invoked during direct reclaim, which I believe is correct—this helps with compaction and is desirable. More on this below.

Quoted 31 lines
Quoted 10 lines
Quoted 9 lines

You also say:

Quoted 1 line

No functional changes are introduced for existing shrinkers.

Consider how many shrinkable caches the general statement above applies to, and then think about the fundamental impedence mismatch between the affected shrinkable caches and what this patch actually fixes.

Quoted 4 lines

Yes, as mentioned above, I’m only addressing Xe here, and I agree that this is likely an issue. Do you know of other shrinkers that have pools or caches which can be shrunk under the conditions I’m introducing here, but also have a working set they would prefer not to give up?

The first that comes to mind is the xfs_buf cache. This cache holds cached metadata buffers that have different sizes can each contain up 64kB of contiguous pages. The allocation algorithm uses optimisitic large folios allocation, but if that fails it falls back to vmalloc. The working set is maintained by a prioritised multi-scan LRU so that more frequently accessed metadata is held tighter by the cache than less frequently accessed (e.g. btree roots have higher retention priority than the lowest leaves).

It does not currently track buffer objects by size, by if there was a benefit to doing so then it could be implemented. I'd much prefer to have such tracking separate to the working set maintenance, especially as they will likely need some kind of balancing to prevent high-order buffers in the working set from being thrashed by compaction demand....

Quoted 4 lines

I know there are other caches that have variable sized objects, but I'd have to go look at the code to referesh my memory of which ones they are...

I'll have to look more here to be able to respond intelligently.

Quoted 11 lines
Quoted 3 lines

If so, a
link on elixir.bootlin.com would be helpful so I can take a look. I’ll also try to go through other shrinkers myself.

cscope is your friend.

fs/xfs/xfs_buf.c contains the XFS buffer cache and shrinker infrastructure, but looking at the code without any understanding of the filesystem structures or how it interacts with the other XFS shrinkable caches probably isn't as useful as you might think it will be.

Agree. Looked at some FS shrinkers and got lost quickly.

Quoted 101 lines
Quoted 24 lines
Quoted 10 lines

For example, what happens to slab-based caches if the XE cache is being excessively reclaimed under high-order page demand? e.g. the slab-based cache may have tens of objects per page and holds a system-level performance critical working set of objects. How do these caches handle the excessive reclaim demand being generated by compaction thrashing?

Yup, they don't.

Agree.

Quoted 10 lines

In the case of filesystem caches, the "reclaim and repopulate" pattern you describe causing the XE perf problems causes internal slab cache fragmentation. Not only does this not improve compaction rates, it also results in more memory fragmentation because slab pages get pinned by a small number of long lived objects and they won't get freed until the cache is largely emptied. IOWs, things get -even worse- from a memory fragmentation POV when compaction thrashing causes the working set of a high-object-count-per-page slab cache to thrash....

Quoted 1 line

Got a link to the code which you are referring to?

Do a lore search for "dentry cache defragmentation". You should be able to find discussions that go back to around 2006 about discussions on identry cache fragmentation and approaches like slab-page based object reclaim to support internal defragmentation.

The fact that we don't have slab cache defragmentation despite many years of people wanting such functionality should tell you how complex the problem is.... :/

Quoted 4 lines

That seems like a problem similar to another issue in DRM/Xe. We found that the process of shrinking actually drove fragmentation by splitting folios down to order-0 and then backing pages up one at a time. I have a separate fix in flight for that.

Possibly, though the life cycle differences I'm talking about can be a few milliseconds (temporary file) vs weeks (long running database instance holding it's table files open the whole time it is running).

Quoted 2 lines

Could the filesystem detect these hints and avoid shrinking in a way that causes fragmentation?

Not really. The fragmentation problem is caused by physical object placement in the slab pages at allocation time, not the act of reclaiming the object.

i.e. we don't know what the expected cache life time of a dentry or an inode will be when we allocate it, so it just gets allocated in the next free slot in the current partial slab page. When you get a mix of dentries that are pinned by open files in long running applications and dentries for access-once files in the same page, we end up with reclaim freeing all the object slots that contained access-once files. However, the pages are still pinned by the objects for the open files that are in active use.

IOWs, LRU-based reclaim can free >90% of the objects in a cache that held millions of objects with mixed lifetimes and still not free any memory at all. There's nothing reclaim can do about it because the problem is created at allocation time when lifetime is a complete unknown.

Quoted 3 lines

Alternatively, could it perform shrinking in
a way that doesn’t shatter folios, or detect long-lived objects so it understands that shrinking isn’t going to help reduce fragmentation?

Referenced filesystem objects are not on the LRUs, so the shrinkers aren't even aware of such long lived objects. And, as per the "dentry cache defrag" comment above, we can't ask the slab to reclaim or move objects because we don't track the owners of external references to the objects themselves.

Quoted 5 lines
Quoted 3 lines

This isn't isolated to individual subsystem thrashing. If we run a file-based workload that generates high-order folio demand and hence

What GFP flags are typical used for file-based workloads?

Mostly GFP_KERNEL, with a mix of GFP_NOFS. non-blocking paths also tend to add GFP_NOWAITS, and memory reclaim sensitive paths often use __GFP_MEMALLOC to prevent reclaim recursion. Some filesystems also make extensive use of GFP_NOFAIL (e.g. XFS).

Quoted 13 lines
Quoted 5 lines

compaction (e.g copy tens of GB of files between two XFS, ext4 or btrfs filesystems), that will -also- trash the Xe working set via the shrinker being hammered by memory compaction try to free up contiguous pages for the page cache.

I could see this.

Quoted 4 lines

Similarly, if we run a Xe workload that generates sustained high order folio demand, that will trash the working set in the dentry and inode caches and any other shrinkable slab-based cache.

Quoted 6 lines
Quoted 3 lines

I could also see this but DRM / Xe will set __GFP_NORETRY or __GFP_RETRY_MAYFAIL on higer-orders so those caches should be able to not trash its working set if looked for this hint.

This relies on all the allocation code everywhere always doing exactly the right thing so that memory reclaim "behaves". That is

Yes and no. The original issue was a DRM/TTM self-feedback loop, where we need some shrinking/reclaim, but not all. In general, this feedback loop also occurs on CPU/GPU client paths, so running XPS alongside heavy DRM/TTM with a client part is a very unlikely use case.

Quoted 5 lines

what I've been saying is not a sustainable approach - all it takes is one allocation or one shrinker not to do the right thing, and we've got another mole to whack. i.e. memory allocation should do the right/best thing for the system with default parameters.

I agree that another allocation could shrink DRM/TTM buffers, but when DRM/TTM reallocates, it won’t trigger the same feedback loop since it uses the correct GFP flags. While it’s true that two conflicting allocations can ping-pong, we are also working on a DRM/TTM reclaim backoff mechanism and a defragmenter. However, if a self-feedback loop exists, this effort becomes ineffective.

Quoted 32 lines
Quoted 16 lines
Quoted 8 lines

Hence the abstracted case of the problem we need to solve is this:
shrinker reclaim is based on x-byte objects is extremely unlikely to acheive contiguous page reclaim in a manner that will measurably improve compaction rates.

This is a problem that has to be addresses by the high level infrastructure level, not worked around by individual shrinkers.

Quoted 7 lines

IMO, compaction shouldn't trigger shrinkers unless the shrinkers are specifically flagged as being able to release contiguous pages of memory in short order. I don't think there's very many shrinkable caches that even hold a significant quantity of objects larger than a single page, so it's clearly questionable as to whether compaction based reclaim should run shrinker reclaim to begin with.

Quoted 2 lines

Yes, sort of do this in Xe by changing '->count_objects' based on the hint.

I know. That's the problem - it's relying on the infrastructure passing down a specific internal context hint in an existing interface so a specific subsystem can work around a specific problematic behaviour.

Indeed, for compaction we don't actually care about the count, what we largely care about is whether the subsystem has any objects the same size or larger than the current compaction demand. Efficient object reclaim for compaction has a different control variable set (e.g. find objects larger than, objects physically near to, etc), and this can't really be properly fitted into the existing count/scan shrinker reclaim algorithm.

Quoted 2 lines

Hence I think it needs new shrinker methods to implement effectively.

Looping back to direct reclaim above—would these new methods also be called during direct reclaim? My thinking is yes.

Quoted 5 lines
Quoted 5 lines
Quoted 4 lines

i.e. a subsystem that can track high order folios in a shrinkable cache should probably have a "->compaction_scan()" method that is run directly from compaction context to try to free high order

Quoted 7 lines
Quoted 3 lines

When you say “compaction context,” which parts of the code are you referring to? I’d like to explore this option, but I need a bit more context.

kcompactd does background compaction, similar to how we have kswapd to do background memory reclaim.

kcompactd doesn't call shrinkers - this is where we'd call compaction shrinkers?

Quoted 4 lines

Direct compaction (part of direct reclaim) via __alloc_pages_direct_compact() that will be called before direct memory reclaim in the case of a high-order allocation.

So maybe this is where compaction shrinkers fits in in direct reclaim?

Quoted 13 lines
Quoted 8 lines
Quoted 6 lines

folios. This provides a direct opt-in mechanism for a subsystem, and it allows subsystems that can track low- and high- order objects independently to efficiently free objects in a way that will help improve compaction rates without impacting the entire working set of objects in the cache.

Quoted 4 lines

Does this help if, for example, the cache is holding onto two order-8 folios that could be freed and merged, while the caller really wants an order-9 folio? This seems like a possible scenario in caches and is certainly true in TTM pools.

Quoted 9 lines

Depends on how the interface is implemented.

IIUC, the direct compaction code will return a right-sized page early if it creates one via compact_zone(). Hence if that path can call into shrinkers to do high-order scanning that results in two mergable order-8 objects being freed and merged into an order-9 object that fulfils the compaction requirements, then it will result in compaction succeeding where it currently fails.

I think this answers my question above - call compaction shrinker here.

Quoted 31 lines
Quoted 6 lines

And I think that kcompactd will run until certain watermarks are met, so again having a high-order shrinker that directly impacts the high order page watermarks would be much more efficient that trying to use general memory pressure to randomly shoot down enough objects to reform contiguous pages.

I think this answers my question above - call compaction shrinker here.

Quoted 22 lines
Quoted 11 lines
Quoted 10 lines

IOWs, this patch to inform kswapd about it's trigger (doesn't it already have a "reason" parameter, though?) is likely a necessary part of the solution - we don't want kswapd running shrinkers if it has been triggered to reclaim pages for compaction. This patch would allows kswapd to elide normal shrinker passes when it has been woken purely for compaction purposes. Given that the compaction code would be running the high-order reclaim capable shrinkers itself, this would avoid trashing the working set of most shrinkable caches -by default- under high order allocation demand....

Quoted 4 lines

I’m trying to parse this—are you suggesting that, one way or another, we introduce a heuristic where shrinkers can act on a hint (whether it’s what I have here or a new ->compaction_scan() vfunc), and then attempt to fix all shrinkers in this series?

I don't want existing shrinkers to be touched at all.

What I want is for memory reclaim (both direct and kswapd) to elide the shrink_slab() calls into shrinkers when memory reclaim is being driven by high order allocation failure.

I went and traced the reclaim/compaction interaction in detail before replying again - I don't think your suggestion works. Let me lay this out in detail with examples.

The premise of eliding shrink_slab() is stated a few times in your reply, e.g.,:

'shrinker reclaim is based on x-byte objects is extremely unlikely to acheive contiguous page reclaim in a manner that will measurably improve compaction rates.'

This is true for some shrinkers, such as slab-based shrinkers, but it is clearly not true for others, such as TTM pools or GPU driver shrinkers that reclaim purgeable or inactive memory outside the working set. Additionally, XFS appears to retain significant amounts of memory through folios and kvmalloc allocations.

This is somewhat of a moot point, though, because producing contiguous memory is not reclaim's responsibility during high-order allocations. Compaction is responsible for creating contiguous memory. Reclaim's job is to free enough pages for compaction to run in the first place.

That's not my reading of intent, it's what the code says:

include/linux/compaction.h:62

/*
* Number of free order-0 pages that should be available above given
* watermark to make sure compaction has reasonable chance of not
* running out of free pages that it needs to isolate as migration
* target during its work.
*/
static inline unsigned long compact_gap(unsigned int order)

mm/vmscan.c:6064, above should_continue_reclaim()

/*
* Reclaim/compaction is used for high-order allocation requests. It
* reclaims order-0 pages before compacting the zone.
* should_continue_reclaim() returns true if more pages should be
* reclaimed such that when the page allocator calls
* try_to_compact_pages() that it will have enough free pages to
* succeed.
*/

So the designed pipeline is "reclaim supplies free pages, compaction assembles them". Scattered order-0 freeing isn't a failure mode of that pipeline, it's the input to it.

The part that makes this concrete rather than philosophical is that the free page supply is a hard gate on compaction, not a soft input to it:

mm/compaction.c:2394, __compaction_suitable()

    watermark += compact_gap(order);
    if (order > PAGE_ALLOC_COSTLY_ORDER)
            watermark += low_wmark_pages(zone) - min_wmark_pages(zone);
    return __zone_watermark_ok(zone, 0, watermark, highest_zoneidx,
                               ALLOC_CMA, free_pages);

mm/compaction.c:2525, compaction_suit_allocation_order()

if (!compaction_suitable(zone, order, watermark, highest_zoneidx))
return COMPACT_SKIPPED;

and compact_zone() bails at line 2563 on anything that isn't COMPACT_CONTINUE.

Below that threshold compaction does not run at all. Not "runs less effectively" - COMPACT_SKIPPED, before the migrate and free scanners are ever started.

Now let's consider two examples:

- A memory-intensive GPU workload has run and completed, leaving pages either in the TTM pool or on the driver side outside the working set.
- XFS reclaimable cache is holding onto large amounts of memory.

If reclaim elides shrink_slab() for all high-order allocations, then on that system:

- the shrinker-owned memory can't be reclaimed at all
- LRU reclaim alone cannot lift NR_FREE_PAGES over watermark + compact_gap(order),
- so compaction_suitable() stays false,
- so compaction never runs,
- so the high-order allocation fails without a single compaction attempt having been made.

Today those allocations succeed, because shrinker-freed pages clear the gate and compaction then does the assembly. So I think eliding shrink_slab() for high-order reclaim would regress high-order/THP allocation success rates.

Hillf made essentially this point upstream in this thread and I don't think it got picked up:

"compaction works only when there are enough free regular pages
available, with nothing to do with shrinker directly"

So my thesis is that shrinkers must run before compaction. We should give shrinkers a hint indicating whether reclaim is being performed opportunistically for high-order allocations, in which case it may not be worth evicting working set data that is expensive to save and restore or if shrinking actively makes fragmentation worse.

I audited the shrinkers and found roughly ten that could make use of this hint. Perhaps the most important is the deferred split shrinker, which actively increases fragmentation when it runs.

By the way, I have the heuristic wrong here, since vma_thp_gfp_mask() will not trigger the opportunistic hint, even though it should because it has a fallback path.

So I'd like to post another revision of this series that fixes the heuristic and also wires the hint up to the deferred split shrinker. Then individual maintainers can decide whether and how to make use of the hint in their own shrinkers.

Matt

Quoted 90 lines

I still think compaction shrinkers need a concept of “opportunistic” versus “must free memory to compact” to avoid the self-feedback loop I described. Without this, the DRM/TTM self-feedback loop would still exist.

Quoted 3 lines

i.e. high-order allocation failure should not generate shrinkable cache memory pressure because shrinkable caches in general cannot return contiguous memory that will allows compaction to make

Yes, I agree with “shrinkable caches in general,” aside from the exceptions I outlined above (though perhaps I’m missing other exceptions).

The risk of what you’re suggesting is that it would suddenly change the entire shrinking model across Linux, and we don’t know what unforeseen consequences this type of change might have. Nor could a single person reasonably test a change of this scope. That’s why an incremental step, like this series—which fixes DRM/TTM as opt-in—may make more sense. As mentioned above, the deferred_split_shrinker is also a very likely candidate for being fixed. That said, I’m going to look into your suggestion as well.

Quoted 5 lines

progress. The existing behaviour has more negative affects on system performance than positive, so we need a fix for "everyone".

I think we should provide a new opt-in ->compaction_scan() method for compaction aware subsystem shrinkers that is run from compact_zone()

compact_zone() appears to be called from both direct reclaim and kcompactd(), so perhaps some of the questions above are already answered.

Quoted 16 lines

context. This allows subsystems that can manage high order objects to optimise the return of high order objects to the free space pool, thereby significantly improving the chance for compaction to succeed without adversely impacting the rest of the shrinkable caches in the system.

Further, we should not kick kswapd because of compaction failures because kcompactd will already be running ->compaction_scan() capable shrinkers from it's callouts to compact_zone() in the background that will do this work as efficiently as possible.

Quoted 4 lines

I’m open to trying to fix other
shrinkers as well. Do you have any particular ones in mind? I count around 45 shrinkers in Linux, so it’s unlikely I can fix every single one, though or all shrinkers need to be fixed.

Quoted 5 lines

They'd all need to be fixed, which is why I suggested a new method to be added. Avoid calling the existing shrinkers in the adverse situation, call the new one from the right context where it actually benefits compaction and high-order memory allocation.

OK, this seems fairly reasonable on its surface despite my concerns above, but see my comment above regarding “opportunistic” vs. “must free memory to compact.” Without that distinction, I don’t think my original problem would be solved.

Given this scope / risks, can I ask for one of two things:

- We move ahead with this series as a stopgap fix, or
- Allow DRM/TTM/Xe to implement shrinker-side heuristics to break the feedback loop

while I work on this larger refactor. This is the type of work I enjoy doing, and I typically have the flexibility to work on what I think is most impactful.

Quoted 10 lines
Quoted 4 lines

On a side note, I just noticed that struct shrinker has count_objects and scan_objects as individual vfuncs rather than using a const struct shrinker_ops *ops. Should we change that? The latter seems cleaner and is typically how things are done in Linux.

We probably should - the current structure is largely historical and there's only ever been two methods. If we are adding another method, then it would probably make sense to add an external ops structure to reduce the memory footprint a little.

Let me look into this as well. I don’t know the exact merge flows for tree-wide changes, but I can figure it out.

Matt

Quoted 4 lines

-Dave.

Signature · 2 lines
Dave Chinner
[email protected]
#8 lore raw

Re: [PATCH v6 1/2] mm: Introduce opportunistic_compaction concept to vmscan and shrinkers

In reply to Dave Chinner
Quoted 44 lines · On Tue, 23 Jun 2026 09:10:43 +1000 Dave Chinner wrote:
Quoted 14 lines · Matthew Brost

High-order allocations using __GFP_NORETRY or __GFP_RETRY_MAYFAIL are often opportunistic attempts to satisfy fragmentation-sensitive allocations rather than indications of severe memory pressure. In these cases, reclaim may invoke shrinkers that aggressively destroy working sets even though reclaim is unlikely to materially improve the allocation outcome.

Some shrinkers manage expensive backing or migration operations where reclaim can result in substantial working set disruption despite the system having sufficient free memory overall. This is particularly visible in fragmentation-heavy workloads where reclaim repeatedly tears down active state while kswapd attempts to satisfy higher-order allocations.

Quoted 6 lines

Introduce an opportunistic_compaction hint in shrink_control that allows kswapd to communicate when reclaim originates from a high-order allocation context that may be fragmentation driven rather than true memory pressure. Shrinkers may use this hint to avoid destructive working set reclaim while still participating normally during order-0 or stronger reclaim conditions.

To be honest, this seems like another "push a hint through to the XE shrinker" mechanism under a different name. You seem so focused on fixing the XE reproducer that the -systemic problem- that -any- high-order folio demand causes is not being acknowleged.

e.g. we use high-order folios extensively in the page cache these days, and there are -many- cases where memory compaction driven by high-order demand cause significant performance regressions for page cache performance. To date, every single person who has wanted to fix the problem they are seeing has effectively attempted to -turn off compaction- via GFP flags.

I've even done that myself inside XFS to work around kvmalloc() issues with a lack of GFP_NOFAIL support and doing costly high order allocations that fail and trigger compaction before falling back to vmalloc(). However, these issues have since been fixed in the kvmalloc() code, such that it now does the right thing for most calling contexts (i.e. tries high-order kmalloc() without triggering compaction, then fall back to GFP_NOFAIL vmalloc()). This has made kvmalloc() more performant and better behaved for -all users-, not just XFS.

Quoted 4 lines

This is not sustainable - we need compaction to be robust and performant in the face of high-order folio demands, regardless of what subsystem is generating the demand.

Because a) compaction works only when there are enough free regular pages available, with nothing to do with shrinker directly, b) both order and gfp are checked in in_reclaim_compaction() in addition to checking __GFP_NORETRY and costly_order in __alloc_pages_slowpath(), I think individual shrinker can have more option by repeating similar check.

author maintainer
#9 lore raw

PATCH v6 2/2 drm/xe: Make use of shrink_control::opportunistic_compaction hint

In reply to Matthew Brost

Xe/TTM backup reclaim can be extremely expensive under fragmentation pressure as reclaim may migrate or destroy actively used GPU working sets despite the system still having substantial free memory available.

Under high-order opportunistic reclaim, repeatedly backing up GPU memory can lead to reclaim/rebind ping-pong behavior where active GPU working sets are continuously torn down and reconstructed without materially improving allocation success.

Use the new shrink_control::opportunistic_compaction hint to avoid Xe backup reclaim during fragmentation-driven high-order reclaim attempts. In this mode the shrinker skips advertising backup-backed reclaimable memory and avoids initiating backup operations entirely.

Order-0 and non-opportunistic reclaim behavior remain unchanged, so Xe backup reclaim still participates normally during genuine memory pressure.

Cc Andrew Morton <[email protected]>
Cc Dave Chinner <[email protected]>
Cc Qi Zheng <[email protected]>
Cc Roman Gushchin <[email protected]>
Cc Muchun Song <[email protected]>
Cc David Hildenbrand <[email protected]>
Cc Lorenzo Stoakes <[email protected]>
Cc "Liam R. Howlett" <[email protected]>
Cc Vlastimil Babka <[email protected]>
Cc Mike Rapoport <[email protected]>
Cc Suren Baghdasaryan <[email protected]>
Cc Michal Hocko <[email protected]>
Cc Johannes Weiner <[email protected]>
Cc Shakeel Butt <[email protected]>
Cc Kairui Song <[email protected]>
Cc Barry Song <[email protected]>
Cc Axel Rasmussen <[email protected]>
Cc Yuanchu Xie <[email protected]>
Cc Wei Xu <[email protected]>
Assisted-by Claude:claude-opus-4.6
---
 drivers/gpu/drm/xe/xe_shrinker.c | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)
drivers/gpu/drm/xe/xe_shrinker.c +17 -3
index 83374cd57660..198149f266c6 100644
@@ -139,10 +139,17 @@ static unsigned long
 xe_shrinker_count(struct shrinker *shrink, struct shrink_control *sc)
 {
 	struct xe_shrinker *shrinker = to_xe_shrinker(shrink);
-	unsigned long num_pages;
+	unsigned long num_pages = 0;
 	bool can_backup = !!(sc->gfp_mask & __GFP_FS);
 
-	num_pages = ttm_backup_bytes_avail() >> PAGE_SHIFT;
+	/*
+	 * Skip accounting backup-able pages when this is an opportunistic
+	 * high-order pass: TTM backup work shrinks at native page granularity
+	 * and is unlikely to produce the contiguous block the caller wants,
+	 * so don't advertise it as reclaimable for this hint.
+	 */
+	if (!sc->opportunistic_compaction)
+		num_pages = ttm_backup_bytes_avail() >> PAGE_SHIFT;
 	read_lock(&shrinker->lock);
 
 	if (can_backup)
@@ -233,7 +240,14 @@ static unsigned long xe_shrinker_scan(struct shrinker *shrink, struct shrink_con
 	}
 
 	sc->nr_scanned = nr_scanned;
-	if (nr_scanned >= nr_to_scan || !can_backup)
+	/*
+	 * Stop after the purge pass for opportunistic high-order reclaim:
+	 * the subsequent backup/writeback pass works at native page order
+	 * and is unlikely to free a contiguous high-order block, so doing
+	 * it here would just churn working sets for no compaction benefit.
+	 */
+	if (nr_scanned >= nr_to_scan || !can_backup ||
+	    sc->opportunistic_compaction)
 		goto out;
 
 	/* If we didn't wake before, try to do it now if needed. */
Signature · 1 line
2.34.1
#10 lore raw

Re: [PATCH v6 2/2] drm/xe: Make use of shrink_control::opportunistic_compaction hint

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] Spurious runtime PM wakeups during opportunistic compaction reclaim. --

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] Spurious runtime PM wakeups during opportunistic compaction reclaim. --

commit 9d2dcd5b46c4108efa18e04768837bf386796338
Author: Matthew Brost <[email protected]>

drm/xe: Make use of shrink_control::opportunistic_compaction hint

This patch uses the new opportunistic_compaction hint in the Xe shrinker to avoid backing up GPU memory during high-order fragmentation-driven reclaim attempts. This prevents reclaim/rebind ping-pong behavior without affecting order-0 reclaim.

Quoted 4 lines
drivers/gpu/drm/xe/xe_shrinker.c +0 -0
index 83374cd576608..198149f266c60 100644

[ ... ]

Quoted 4 lines
drivers/gpu/drm/xe/xe_shrinker.c +0 -0
@@ -233,7 +240,14 @@ static unsigned long xe_shrinker_scan(struct shrinker *shrink, struct shrink_con
 	}
 
 	sc->nr_scanned = nr_scanned;

drivers/gpu/drm/xe/xe_shrinker.c static unsigned long xe_shrinker_scan(struct shrinker *shrink, struct shrink_con · line 251

Quoted 10 lines
drivers/gpu/drm/xe/xe_shrinker.c +8 -1
-	if (nr_scanned >= nr_to_scan || !can_backup)
+	/*
+	 * Stop after the purge pass for opportunistic high-order reclaim:
+	 * the subsequent backup/writeback pass works at native page order
+	 * and is unlikely to free a contiguous high-order block, so doing
+	 * it here would just churn working sets for no compaction benefit.
+	 */
+	if (nr_scanned >= nr_to_scan || !can_backup ||
+	    sc->opportunistic_compaction)
 		goto out;

[Severity: Medium]
Does this cause a spurious runtime PM wakeup during opportunistic compaction?

Looking earlier in xe_shrinker_scan(), xe_shrinker_runtime_pm_get() is called to eagerly wake up the device based on the can_backup flag:

	/* Might need runtime PM. Try to wake early if it looks like it. */
	runtime_pm = xe_shrinker_runtime_pm_get(shrinker, false, nr_to_scan, can_backup);

Since the early exit above skips the backup phase when opportunistic compaction is requested, an asynchronous worker might still be queued to wake the GPU from suspend even though the backup pass will never run.

Could the can_backup flag be updated to also incorporate the sc->opportunistic_compaction state to prevent these wakeups?

Quoted 2 lines
drivers/gpu/drm/xe/xe_shrinker.c +0 -0
 	/* If we didn't wake before, try to do it now if needed. */
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=2
#11 lore raw

✓ CI.KUnit: success for mm, drm/xe: Avoid reclaim/eviction loops under fragmentation

In reply to Matthew Brost
== Series Details ==

== Series Details ==

Series: mm, drm/xe: Avoid reclaim/eviction loops under fragmentation
URL : https://patchwork.freedesktop.org/series/168651/
State : success

== Summary ==

+ trap cleanup EXIT
+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/xe/.kunitconfig [04:35:51] Configuring KUnit Kernel ...
Generating .config ...
Populating config with:

$ make ARCH=um O=.kunit olddefconfig
[04:35:56] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[04:36:27] Starting KUnit Kernel (1/1)...
[04:36:27] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[04:36:27] ================== guc_buf (11 subtests) ===================
[04:36:27] [PASSED] test_smallest
[04:36:27] [PASSED] test_largest
[04:36:27] [PASSED] test_granular
[04:36:27] [PASSED] test_unique
[04:36:27] [PASSED] test_overlap
[04:36:27] [PASSED] test_reusable
[04:36:27] [PASSED] test_too_big
[04:36:27] [PASSED] test_flush
[04:36:27] [PASSED] test_lookup
[04:36:27] [PASSED] test_data
[04:36:27] [PASSED] test_class
[04:36:27] ===================== [PASSED] guc_buf =====================
[04:36:27] =================== guc_dbm (7 subtests) ===================
[04:36:27] [PASSED] test_empty
[04:36:27] [PASSED] test_default
[04:36:27] ======================== test_size  ========================
[04:36:27] [PASSED] 4
[04:36:27] [PASSED] 8
[04:36:27] [PASSED] 32
[04:36:27] [PASSED] 256
[04:36:27] ==================== [PASSED] test_size ====================
[04:36:27] ======================= test_reuse  ========================
[04:36:27] [PASSED] 4
[04:36:27] [PASSED] 8
[04:36:27] [PASSED] 32
[04:36:27] [PASSED] 256
[04:36:27] =================== [PASSED] test_reuse ====================
[04:36:27] =================== test_range_overlap  ====================
[04:36:27] [PASSED] 4
[04:36:27] [PASSED] 8
[04:36:27] [PASSED] 32
[04:36:27] [PASSED] 256
[04:36:27] =============== [PASSED] test_range_overlap ================
[04:36:27] =================== test_range_compact  ====================
[04:36:27] [PASSED] 4
[04:36:27] [PASSED] 8
[04:36:27] [PASSED] 32
[04:36:27] [PASSED] 256
[04:36:27] =============== [PASSED] test_range_compact ================
[04:36:27] ==================== test_range_spare  =====================
[04:36:27] [PASSED] 4
[04:36:27] [PASSED] 8
[04:36:27] [PASSED] 32
[04:36:27] [PASSED] 256
[04:36:27] ================ [PASSED] test_range_spare =================
[04:36:27] ===================== [PASSED] guc_dbm =====================
[04:36:27] =================== guc_idm (6 subtests) ===================
[04:36:27] [PASSED] bad_init
[04:36:27] [PASSED] no_init
[04:36:27] [PASSED] init_fini
[04:36:27] [PASSED] check_used
[04:36:27] [PASSED] check_quota
[04:36:27] [PASSED] check_all
[04:36:27] ===================== [PASSED] guc_idm =====================
[04:36:27] ================== no_relay (3 subtests) ===================
[04:36:27] [PASSED] xe_drops_guc2pf_if_not_ready
[04:36:27] [PASSED] xe_drops_guc2vf_if_not_ready
[04:36:27] [PASSED] xe_rejects_send_if_not_ready
[04:36:27] ==================== [PASSED] no_relay =====================
[04:36:27] ================== pf_relay (14 subtests) ==================
[04:36:27] [PASSED] pf_rejects_guc2pf_too_short
[04:36:27] [PASSED] pf_rejects_guc2pf_too_long
[04:36:27] [PASSED] pf_rejects_guc2pf_no_payload
[04:36:27] [PASSED] pf_fails_no_payload
[04:36:27] [PASSED] pf_fails_bad_origin
[04:36:27] [PASSED] pf_fails_bad_type
[04:36:27] [PASSED] pf_txn_reports_error
[04:36:27] [PASSED] pf_txn_sends_pf2guc
[04:36:27] [PASSED] pf_sends_pf2guc
[04:36:27] [SKIPPED] pf_loopback_nop
[04:36:27] [SKIPPED] pf_loopback_echo
[04:36:27] [SKIPPED] pf_loopback_fail
[04:36:27] [SKIPPED] pf_loopback_busy
[04:36:27] [SKIPPED] pf_loopback_retry
[04:36:27] ==================== [PASSED] pf_relay =====================
[04:36:27] ================== vf_relay (3 subtests) ===================
[04:36:27] [PASSED] vf_rejects_guc2vf_too_short
[04:36:27] [PASSED] vf_rejects_guc2vf_too_long
[04:36:27] [PASSED] vf_rejects_guc2vf_no_payload
[04:36:27] ==================== [PASSED] vf_relay =====================
[04:36:27] ================ pf_gt_config (9 subtests) =================
[04:36:27] [PASSED] fair_contexts_1vf
[04:36:27] [PASSED] fair_doorbells_1vf
[04:36:27] [PASSED] fair_ggtt_1vf
[04:36:27] ====================== fair_vram_1vf  ======================
[04:36:27] [PASSED] 3.50 GiB
[04:36:27] [PASSED] 11.5 GiB
[04:36:27] [PASSED] 15.5 GiB
[04:36:27] [PASSED] 31.5 GiB
[04:36:27] [PASSED] 63.5 GiB
[04:36:27] [PASSED] 1.91 GiB
[04:36:27] ================== [PASSED] fair_vram_1vf ==================
[04:36:27] ================ fair_vram_1vf_admin_only  =================
[04:36:27] [PASSED] 3.50 GiB
[04:36:27] [PASSED] 11.5 GiB
[04:36:27] [PASSED] 15.5 GiB
[04:36:27] [PASSED] 31.5 GiB
[04:36:27] [PASSED] 63.5 GiB
[04:36:27] [PASSED] 1.91 GiB
[04:36:27] ============ [PASSED] fair_vram_1vf_admin_only =============
[04:36:27] ====================== fair_contexts  ======================
[04:36:27] [PASSED] 1 VF
[04:36:27] [PASSED] 2 VFs
[04:36:27] [PASSED] 3 VFs
[04:36:27] [PASSED] 4 VFs
[04:36:27] [PASSED] 5 VFs
[04:36:27] [PASSED] 6 VFs
[04:36:27] [PASSED] 7 VFs
[04:36:27] [PASSED] 8 VFs
[04:36:27] [PASSED] 9 VFs
[04:36:27] [PASSED] 10 VFs
[04:36:27] [PASSED] 11 VFs
[04:36:27] [PASSED] 12 VFs
[04:36:27] [PASSED] 13 VFs
[04:36:27] [PASSED] 14 VFs
[04:36:27] [PASSED] 15 VFs
[04:36:27] [PASSED] 16 VFs
[04:36:27] [PASSED] 17 VFs
[04:36:27] [PASSED] 18 VFs
[04:36:27] [PASSED] 19 VFs
[04:36:27] [PASSED] 20 VFs
[04:36:27] [PASSED] 21 VFs
[04:36:27] [PASSED] 22 VFs
[04:36:27] [PASSED] 23 VFs
[04:36:27] [PASSED] 24 VFs
[04:36:27] [PASSED] 25 VFs
[04:36:27] [PASSED] 26 VFs
[04:36:27] [PASSED] 27 VFs
[04:36:27] [PASSED] 28 VFs
[04:36:27] [PASSED] 29 VFs
[04:36:27] [PASSED] 30 VFs
[04:36:27] [PASSED] 31 VFs
[04:36:27] [PASSED] 32 VFs
[04:36:27] [PASSED] 33 VFs
[04:36:27] [PASSED] 34 VFs
[04:36:27] [PASSED] 35 VFs
[04:36:27] [PASSED] 36 VFs
[04:36:27] [PASSED] 37 VFs
[04:36:27] [PASSED] 38 VFs
[04:36:27] [PASSED] 39 VFs
[04:36:27] [PASSED] 40 VFs
[04:36:27] [PASSED] 41 VFs
[04:36:27] [PASSED] 42 VFs
[04:36:27] [PASSED] 43 VFs
[04:36:27] [PASSED] 44 VFs
[04:36:27] [PASSED] 45 VFs
[04:36:27] [PASSED] 46 VFs
[04:36:27] [PASSED] 47 VFs
[04:36:27] [PASSED] 48 VFs
[04:36:27] [PASSED] 49 VFs
[04:36:27] [PASSED] 50 VFs
[04:36:27] [PASSED] 51 VFs
[04:36:27] [PASSED] 52 VFs
[04:36:27] [PASSED] 53 VFs
[04:36:27] [PASSED] 54 VFs
[04:36:27] [PASSED] 55 VFs
[04:36:27] [PASSED] 56 VFs
[04:36:27] [PASSED] 57 VFs
[04:36:27] [PASSED] 58 VFs
[04:36:27] [PASSED] 59 VFs
[04:36:27] [PASSED] 60 VFs
[04:36:27] [PASSED] 61 VFs
[04:36:27] [PASSED] 62 VFs
[04:36:27] [PASSED] 63 VFs
[04:36:27] ================== [PASSED] fair_contexts ==================
[04:36:27] ===================== fair_doorbells  ======================
[04:36:27] [PASSED] 1 VF
[04:36:27] [PASSED] 2 VFs
[04:36:27] [PASSED] 3 VFs
[04:36:27] [PASSED] 4 VFs
[04:36:27] [PASSED] 5 VFs
[04:36:27] [PASSED] 6 VFs
[04:36:27] [PASSED] 7 VFs
[04:36:27] [PASSED] 8 VFs
[04:36:27] [PASSED] 9 VFs
[04:36:27] [PASSED] 10 VFs
[04:36:27] [PASSED] 11 VFs
[04:36:27] [PASSED] 12 VFs
[04:36:27] [PASSED] 13 VFs
[04:36:27] [PASSED] 14 VFs
[04:36:27] [PASSED] 15 VFs
[04:36:27] [PASSED] 16 VFs
[04:36:27] [PASSED] 17 VFs
[04:36:27] [PASSED] 18 VFs
[04:36:27] [PASSED] 19 VFs
[04:36:27] [PASSED] 20 VFs
[04:36:27] [PASSED] 21 VFs
[04:36:27] [PASSED] 22 VFs
[04:36:27] [PASSED] 23 VFs
[04:36:27] [PASSED] 24 VFs
[04:36:27] [PASSED] 25 VFs
[04:36:27] [PASSED] 26 VFs
[04:36:27] [PASSED] 27 VFs
[04:36:27] [PASSED] 28 VFs
[04:36:27] [PASSED] 29 VFs
[04:36:27] [PASSED] 30 VFs
[04:36:27] [PASSED] 31 VFs
[04:36:27] [PASSED] 32 VFs
[04:36:27] [PASSED] 33 VFs
[04:36:27] [PASSED] 34 VFs
[04:36:27] [PASSED] 35 VFs
[04:36:27] [PASSED] 36 VFs
[04:36:27] [PASSED] 37 VFs
[04:36:27] [PASSED] 38 VFs
[04:36:27] [PASSED] 39 VFs
[04:36:27] [PASSED] 40 VFs
[04:36:27] [PASSED] 41 VFs
[04:36:27] [PASSED] 42 VFs
[04:36:27] [PASSED] 43 VFs
[04:36:27] [PASSED] 44 VFs
[04:36:27] [PASSED] 45 VFs
[04:36:27] [PASSED] 46 VFs
[04:36:27] [PASSED] 47 VFs
[04:36:27] [PASSED] 48 VFs
[04:36:27] [PASSED] 49 VFs
[04:36:27] [PASSED] 50 VFs
[04:36:27] [PASSED] 51 VFs
[04:36:27] [PASSED] 52 VFs
[04:36:27] [PASSED] 53 VFs
[04:36:27] [PASSED] 54 VFs
[04:36:27] [PASSED] 55 VFs
[04:36:27] [PASSED] 56 VFs
[04:36:27] [PASSED] 57 VFs
[04:36:27] [PASSED] 58 VFs
[04:36:27] [PASSED] 59 VFs
[04:36:27] [PASSED] 60 VFs
[04:36:27] [PASSED] 61 VFs
[04:36:27] [PASSED] 62 VFs
[04:36:27] [PASSED] 63 VFs
[04:36:27] ================= [PASSED] fair_doorbells ==================
[04:36:27] ======================== fair_ggtt  ========================
[04:36:27] [PASSED] 1 VF
[04:36:27] [PASSED] 2 VFs
[04:36:27] [PASSED] 3 VFs
[04:36:27] [PASSED] 4 VFs
[04:36:27] [PASSED] 5 VFs
[04:36:27] [PASSED] 6 VFs
[04:36:27] [PASSED] 7 VFs
[04:36:27] [PASSED] 8 VFs
[04:36:27] [PASSED] 9 VFs
[04:36:27] [PASSED] 10 VFs
[04:36:27] [PASSED] 11 VFs
[04:36:27] [PASSED] 12 VFs
[04:36:27] [PASSED] 13 VFs
[04:36:27] [PASSED] 14 VFs
[04:36:27] [PASSED] 15 VFs
[04:36:27] [PASSED] 16 VFs
[04:36:27] [PASSED] 17 VFs
[04:36:27] [PASSED] 18 VFs
[04:36:27] [PASSED] 19 VFs
[04:36:27] [PASSED] 20 VFs
[04:36:27] [PASSED] 21 VFs
[04:36:27] [PASSED] 22 VFs
[04:36:27] [PASSED] 23 VFs
[04:36:27] [PASSED] 24 VFs
[04:36:27] [PASSED] 25 VFs
[04:36:27] [PASSED] 26 VFs
[04:36:27] [PASSED] 27 VFs
[04:36:27] [PASSED] 28 VFs
[04:36:27] [PASSED] 29 VFs
[04:36:27] [PASSED] 30 VFs
[04:36:27] [PASSED] 31 VFs
[04:36:27] [PASSED] 32 VFs
[04:36:27] [PASSED] 33 VFs
[04:36:27] [PASSED] 34 VFs
[04:36:27] [PASSED] 35 VFs
[04:36:27] [PASSED] 36 VFs
[04:36:27] [PASSED] 37 VFs
[04:36:27] [PASSED] 38 VFs
[04:36:27] [PASSED] 39 VFs
[04:36:27] [PASSED] 40 VFs
[04:36:27] [PASSED] 41 VFs
[04:36:27] [PASSED] 42 VFs
[04:36:27] [PASSED] 43 VFs
[04:36:27] [PASSED] 44 VFs
[04:36:27] [PASSED] 45 VFs
[04:36:27] [PASSED] 46 VFs
[04:36:27] [PASSED] 47 VFs
[04:36:27] [PASSED] 48 VFs
[04:36:27] [PASSED] 49 VFs
[04:36:27] [PASSED] 50 VFs
[04:36:27] [PASSED] 51 VFs
[04:36:27] [PASSED] 52 VFs
[04:36:27] [PASSED] 53 VFs
[04:36:27] [PASSED] 54 VFs
[04:36:27] [PASSED] 55 VFs
[04:36:27] [PASSED] 56 VFs
[04:36:27] [PASSED] 57 VFs
[04:36:27] [PASSED] 58 VFs
[04:36:27] [PASSED] 59 VFs
[04:36:27] [PASSED] 60 VFs
[04:36:27] [PASSED] 61 VFs
[04:36:27] [PASSED] 62 VFs
[04:36:27] [PASSED] 63 VFs
[04:36:27] ==================== [PASSED] fair_ggtt ====================
[04:36:27] ======================== fair_vram  ========================
[04:36:27] [PASSED] 1 VF
[04:36:27] [PASSED] 2 VFs
[04:36:27] [PASSED] 3 VFs
[04:36:27] [PASSED] 4 VFs
[04:36:27] [PASSED] 5 VFs
[04:36:27] [PASSED] 6 VFs
[04:36:27] [PASSED] 7 VFs
[04:36:27] [PASSED] 8 VFs
[04:36:27] [PASSED] 9 VFs
[04:36:27] [PASSED] 10 VFs
[04:36:27] [PASSED] 11 VFs
[04:36:27] [PASSED] 12 VFs
[04:36:27] [PASSED] 13 VFs
[04:36:27] [PASSED] 14 VFs
[04:36:27] [PASSED] 15 VFs
[04:36:27] [PASSED] 16 VFs
[04:36:27] [PASSED] 17 VFs
[04:36:27] [PASSED] 18 VFs
[04:36:27] [PASSED] 19 VFs
[04:36:27] [PASSED] 20 VFs
[04:36:27] [PASSED] 21 VFs
[04:36:27] [PASSED] 22 VFs
[04:36:27] [PASSED] 23 VFs
[04:36:27] [PASSED] 24 VFs
[04:36:27] [PASSED] 25 VFs
[04:36:27] [PASSED] 26 VFs
[04:36:27] [PASSED] 27 VFs
[04:36:27] [PASSED] 28 VFs
[04:36:27] [PASSED] 29 VFs
[04:36:27] [PASSED] 30 VFs
[04:36:27] [PASSED] 31 VFs
[04:36:27] [PASSED] 32 VFs
[04:36:27] [PASSED] 33 VFs
[04:36:27] [PASSED] 34 VFs
[04:36:27] [PASSED] 35 VFs
[04:36:27] [PASSED] 36 VFs
[04:36:27] [PASSED] 37 VFs
[04:36:28] [PASSED] 38 VFs
[04:36:28] [PASSED] 39 VFs
[04:36:28] [PASSED] 40 VFs
[04:36:28] [PASSED] 41 VFs
[04:36:28] [PASSED] 42 VFs
[04:36:28] [PASSED] 43 VFs
[04:36:28] [PASSED] 44 VFs
[04:36:28] [PASSED] 45 VFs
[04:36:28] [PASSED] 46 VFs
[04:36:28] [PASSED] 47 VFs
[04:36:28] [PASSED] 48 VFs
[04:36:28] [PASSED] 49 VFs
[04:36:28] [PASSED] 50 VFs
[04:36:28] [PASSED] 51 VFs
[04:36:28] [PASSED] 52 VFs
[04:36:28] [PASSED] 53 VFs
[04:36:28] [PASSED] 54 VFs
[04:36:28] [PASSED] 55 VFs
[04:36:28] [PASSED] 56 VFs
[04:36:28] [PASSED] 57 VFs
[04:36:28] [PASSED] 58 VFs
[04:36:28] [PASSED] 59 VFs
[04:36:28] [PASSED] 60 VFs
[04:36:28] [PASSED] 61 VFs
[04:36:28] [PASSED] 62 VFs
[04:36:28] [PASSED] 63 VFs
[04:36:28] ==================== [PASSED] fair_vram ====================
[04:36:28] ================== [PASSED] pf_gt_config ===================
[04:36:28] ===================== lmtt (1 subtest) =====================
[04:36:28] ======================== test_ops  =========================
[04:36:28] [PASSED] 2-level
[04:36:28] [PASSED] multi-level
[04:36:28] ==================== [PASSED] test_ops =====================
[04:36:28] ====================== [PASSED] lmtt =======================
[04:36:28] ================= pf_service (11 subtests) =================
[04:36:28] [PASSED] pf_negotiate_any
[04:36:28] [PASSED] pf_negotiate_base_match
[04:36:28] [PASSED] pf_negotiate_base_newer
[04:36:28] [PASSED] pf_negotiate_base_next
[04:36:28] [SKIPPED] pf_negotiate_base_older
[04:36:28] [PASSED] pf_negotiate_base_prev
[04:36:28] [PASSED] pf_negotiate_latest_match
[04:36:28] [PASSED] pf_negotiate_latest_newer
[04:36:28] [PASSED] pf_negotiate_latest_next
[04:36:28] [SKIPPED] pf_negotiate_latest_older
[04:36:28] [SKIPPED] pf_negotiate_latest_prev
[04:36:28] =================== [PASSED] pf_service ====================
[04:36:28] ================= xe_guc_g2g (2 subtests) ==================
[04:36:28] ============== xe_live_guc_g2g_kunit_default  ==============
[04:36:28] ========= [SKIPPED] xe_live_guc_g2g_kunit_default ==========
[04:36:28] ============== xe_live_guc_g2g_kunit_allmem  ===============
[04:36:28] ========== [SKIPPED] xe_live_guc_g2g_kunit_allmem ==========
[04:36:28] =================== [SKIPPED] xe_guc_g2g ===================
[04:36:28] =================== xe_mocs (2 subtests) ===================
[04:36:28] ================ xe_live_mocs_kernel_kunit  ================
[04:36:28] =========== [SKIPPED] xe_live_mocs_kernel_kunit ============
[04:36:28] ================ xe_live_mocs_reset_kunit  =================
[04:36:28] ============ [SKIPPED] xe_live_mocs_reset_kunit ============
[04:36:28] ==================== [SKIPPED] xe_mocs =====================
[04:36:28] ================= xe_migrate (2 subtests) ==================
[04:36:28] ================= xe_migrate_sanity_kunit  =================
[04:36:28] ============ [SKIPPED] xe_migrate_sanity_kunit =============
[04:36:28] ================== xe_validate_ccs_kunit  ==================
[04:36:28] ============= [SKIPPED] xe_validate_ccs_kunit ==============
[04:36:28] =================== [SKIPPED] xe_migrate ===================
[04:36:28] ================== xe_dma_buf (1 subtest) ==================
[04:36:28] ==================== xe_dma_buf_kunit  =====================
[04:36:28] ================ [SKIPPED] xe_dma_buf_kunit ================
[04:36:28] =================== [SKIPPED] xe_dma_buf ===================
[04:36:28] ================= xe_bo_shrink (1 subtest) =================
[04:36:28] =================== xe_bo_shrink_kunit  ====================
[04:36:28] =============== [SKIPPED] xe_bo_shrink_kunit ===============
[04:36:28] ================== [SKIPPED] xe_bo_shrink ==================
[04:36:28] ==================== xe_bo (2 subtests) ====================
[04:36:28] ================== xe_ccs_migrate_kunit  ===================
[04:36:28] ============== [SKIPPED] xe_ccs_migrate_kunit ==============
[04:36:28] ==================== xe_bo_evict_kunit  ====================
[04:36:28] =============== [SKIPPED] xe_bo_evict_kunit ================
[04:36:28] ===================== [SKIPPED] xe_bo ======================
[04:36:28] ==================== args (13 subtests) ====================
[04:36:28] [PASSED] count_args_test
[04:36:28] [PASSED] call_args_example
[04:36:28] [PASSED] call_args_test
[04:36:28] [PASSED] drop_first_arg_example
[04:36:28] [PASSED] drop_first_arg_test
[04:36:28] [PASSED] first_arg_example
[04:36:28] [PASSED] first_arg_test
[04:36:28] [PASSED] last_arg_example
[04:36:28] [PASSED] last_arg_test
[04:36:28] [PASSED] pick_arg_example
[04:36:28] [PASSED] if_args_example
[04:36:28] [PASSED] if_args_test
[04:36:28] [PASSED] sep_comma_example
[04:36:28] ====================== [PASSED] args =======================
[04:36:28] =================== xe_pci (3 subtests) ====================
[04:36:28] ==================== check_graphics_ip  ====================
[04:36:28] [PASSED] 12.00 Xe_LP
[04:36:28] [PASSED] 12.10 Xe_LP+
[04:36:28] [PASSED] 12.55 Xe_HPG
[04:36:28] [PASSED] 12.60 Xe_HPC
[04:36:28] [PASSED] 12.70 Xe_LPG
[04:36:28] [PASSED] 12.71 Xe_LPG
[04:36:28] [PASSED] 12.74 Xe_LPG+
[04:36:28] [PASSED] 20.01 Xe2_HPG
[04:36:28] [PASSED] 20.02 Xe2_HPG
[04:36:28] [PASSED] 20.04 Xe2_LPG
[04:36:28] [PASSED] 30.00 Xe3_LPG
[04:36:28] [PASSED] 30.01 Xe3_LPG
[04:36:28] [PASSED] 30.03 Xe3_LPG
[04:36:28] [PASSED] 30.04 Xe3_LPG
[04:36:28] [PASSED] 30.05 Xe3_LPG
[04:36:28] [PASSED] 35.10 Xe3p_LPG
[04:36:28] [PASSED] 35.11 Xe3p_XPC
[04:36:28] ================ [PASSED] check_graphics_ip ================
[04:36:28] ===================== check_media_ip  ======================
[04:36:28] [PASSED] 12.00 Xe_M
[04:36:28] [PASSED] 12.55 Xe_HPM
[04:36:28] [PASSED] 13.00 Xe_LPM+
[04:36:28] [PASSED] 13.01 Xe2_HPM
[04:36:28] [PASSED] 20.00 Xe2_LPM
[04:36:28] [PASSED] 30.00 Xe3_LPM
[04:36:28] [PASSED] 30.02 Xe3_LPM
[04:36:28] [PASSED] 35.00 Xe3p_LPM
[04:36:28] [PASSED] 35.03 Xe3p_HPM
[04:36:28] ================= [PASSED] check_media_ip ==================
[04:36:28] =================== check_platform_desc  ===================
[04:36:28] [PASSED] 0x9A60 (TIGERLAKE)
[04:36:28] [PASSED] 0x9A68 (TIGERLAKE)
[04:36:28] [PASSED] 0x9A70 (TIGERLAKE)
[04:36:28] [PASSED] 0x9A40 (TIGERLAKE)
[04:36:28] [PASSED] 0x9A49 (TIGERLAKE)
[04:36:28] [PASSED] 0x9A59 (TIGERLAKE)
[04:36:28] [PASSED] 0x9A78 (TIGERLAKE)
[04:36:28] [PASSED] 0x9AC0 (TIGERLAKE)
[04:36:28] [PASSED] 0x9AC9 (TIGERLAKE)
[04:36:28] [PASSED] 0x9AD9 (TIGERLAKE)
[04:36:28] [PASSED] 0x9AF8 (TIGERLAKE)
[04:36:28] [PASSED] 0x4C80 (ROCKETLAKE)
[04:36:28] [PASSED] 0x4C8A (ROCKETLAKE)
[04:36:28] [PASSED] 0x4C8B (ROCKETLAKE)
[04:36:28] [PASSED] 0x4C8C (ROCKETLAKE)
[04:36:28] [PASSED] 0x4C90 (ROCKETLAKE)
[04:36:28] [PASSED] 0x4C9A (ROCKETLAKE)
[04:36:28] [PASSED] 0x4680 (ALDERLAKE_S)
[04:36:28] [PASSED] 0x4682 (ALDERLAKE_S)
[04:36:28] [PASSED] 0x4688 (ALDERLAKE_S)
[04:36:28] [PASSED] 0x468A (ALDERLAKE_S)
[04:36:28] [PASSED] 0x468B (ALDERLAKE_S)
[04:36:28] [PASSED] 0x4690 (ALDERLAKE_S)
[04:36:28] [PASSED] 0x4692 (ALDERLAKE_S)
[04:36:28] [PASSED] 0x4693 (ALDERLAKE_S)
[04:36:28] [PASSED] 0x46A0 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46A1 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46A2 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46A3 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46A6 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46A8 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46AA (ALDERLAKE_P)
[04:36:28] [PASSED] 0x462A (ALDERLAKE_P)
[04:36:28] [PASSED] 0x4626 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x4628 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46B0 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46B1 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46B2 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46B3 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46C0 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46C1 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46C2 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46C3 (ALDERLAKE_P)
[04:36:28] [PASSED] 0x46D0 (ALDERLAKE_N)
[04:36:28] [PASSED] 0x46D1 (ALDERLAKE_N)
[04:36:28] [PASSED] 0x46D2 (ALDERLAKE_N)
[04:36:28] [PASSED] 0x46D3 (ALDERLAKE_N)
[04:36:28] [PASSED] 0x46D4 (ALDERLAKE_N)
[04:36:28] [PASSED] 0xA721 (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA7A1 (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA7A9 (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA7AC (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA7AD (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA720 (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA7A0 (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA7A8 (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA7AA (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA7AB (ALDERLAKE_P)
[04:36:28] [PASSED] 0xA780 (ALDERLAKE_S)
[04:36:28] [PASSED] 0xA781 (ALDERLAKE_S)
[04:36:28] [PASSED] 0xA782 (ALDERLAKE_S)
[04:36:28] [PASSED] 0xA783 (ALDERLAKE_S)
[04:36:28] [PASSED] 0xA788 (ALDERLAKE_S)
[04:36:28] [PASSED] 0xA789 (ALDERLAKE_S)
[04:36:28] [PASSED] 0xA78A (ALDERLAKE_S)
[04:36:28] [PASSED] 0xA78B (ALDERLAKE_S)
[04:36:28] [PASSED] 0x4905 (DG1)
[04:36:28] [PASSED] 0x4906 (DG1)
[04:36:28] [PASSED] 0x4907 (DG1)
[04:36:28] [PASSED] 0x4908 (DG1)
[04:36:28] [PASSED] 0x4909 (DG1)
[04:36:28] [PASSED] 0x56C0 (DG2)
[04:36:28] [PASSED] 0x56C2 (DG2)
[04:36:28] [PASSED] 0x56C1 (DG2)
[04:36:28] [PASSED] 0x7D51 (METEORLAKE)
[04:36:28] [PASSED] 0x7DD1 (METEORLAKE)
[04:36:28] [PASSED] 0x7D41 (METEORLAKE)
[04:36:28] [PASSED] 0x7D67 (METEORLAKE)
[04:36:28] [PASSED] 0xB640 (METEORLAKE)
[04:36:28] [PASSED] 0x56A0 (DG2)
[04:36:28] [PASSED] 0x56A1 (DG2)
[04:36:28] [PASSED] 0x56A2 (DG2)
[04:36:28] [PASSED] 0x56BE (DG2)
[04:36:28] [PASSED] 0x56BF (DG2)
[04:36:28] [PASSED] 0x5690 (DG2)
[04:36:28] [PASSED] 0x5691 (DG2)
[04:36:28] [PASSED] 0x5692 (DG2)
[04:36:28] [PASSED] 0x56A5 (DG2)
[04:36:28] [PASSED] 0x56A6 (DG2)
[04:36:28] [PASSED] 0x56B0 (DG2)
[04:36:28] [PASSED] 0x56B1 (DG2)
[04:36:28] [PASSED] 0x56BA (DG2)
[04:36:28] [PASSED] 0x56BB (DG2)
[04:36:28] [PASSED] 0x56BC (DG2)
[04:36:28] [PASSED] 0x56BD (DG2)
[04:36:28] [PASSED] 0x5693 (DG2)
[04:36:28] [PASSED] 0x5694 (DG2)
[04:36:28] [PASSED] 0x5695 (DG2)
[04:36:28] [PASSED] 0x56A3 (DG2)
[04:36:28] [PASSED] 0x56A4 (DG2)
[04:36:28] [PASSED] 0x56B2 (DG2)
[04:36:28] [PASSED] 0x56B3 (DG2)
[04:36:28] [PASSED] 0x5696 (DG2)
[04:36:28] [PASSED] 0x5697 (DG2)
[04:36:28] [PASSED] 0xB69 (PVC)
[04:36:28] [PASSED] 0xB6E (PVC)
[04:36:28] [PASSED] 0xBD4 (PVC)
[04:36:28] [PASSED] 0xBD5 (PVC)
[04:36:28] [PASSED] 0xBD6 (PVC)
[04:36:28] [PASSED] 0xBD7 (PVC)
[04:36:28] [PASSED] 0xBD8 (PVC)
[04:36:28] [PASSED] 0xBD9 (PVC)
[04:36:28] [PASSED] 0xBDA (PVC)
[04:36:28] [PASSED] 0xBDB (PVC)
[04:36:28] [PASSED] 0xBE0 (PVC)
[04:36:28] [PASSED] 0xBE1 (PVC)
[04:36:28] [PASSED] 0xBE5 (PVC)
[04:36:28] [PASSED] 0x7D40 (METEORLAKE)
[04:36:28] [PASSED] 0x7D45 (METEORLAKE)
[04:36:28] [PASSED] 0x7D55 (METEORLAKE)
[04:36:28] [PASSED] 0x7D60 (METEORLAKE)
[04:36:28] [PASSED] 0x7DD5 (METEORLAKE)
[04:36:28] [PASSED] 0x6420 (LUNARLAKE)
[04:36:28] [PASSED] 0x64A0 (LUNARLAKE)
[04:36:28] [PASSED] 0x64B0 (LUNARLAKE)
[04:36:28] [PASSED] 0xE202 (BATTLEMAGE)
[04:36:28] [PASSED] 0xE209 (BATTLEMAGE)
[04:36:28] [PASSED] 0xE20B (BATTLEMAGE)
[04:36:28] [PASSED] 0xE20C (BATTLEMAGE)
[04:36:28] [PASSED] 0xE20D (BATTLEMAGE)
[04:36:28] [PASSED] 0xE210 (BATTLEMAGE)
[04:36:28] [PASSED] 0xE211 (BATTLEMAGE)
[04:36:28] [PASSED] 0xE212 (BATTLEMAGE)
[04:36:28] [PASSED] 0xE216 (BATTLEMAGE)
[04:36:28] [PASSED] 0xE220 (BATTLEMAGE)
[04:36:28] [PASSED] 0xE221 (BATTLEMAGE)
[04:36:28] [PASSED] 0xE222 (BATTLEMAGE)
[04:36:28] [PASSED] 0xE223 (BATTLEMAGE)
[04:36:28] [PASSED] 0xB080 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB081 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB082 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB083 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB084 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB085 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB086 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB087 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB08F (PANTHERLAKE)
[04:36:28] [PASSED] 0xB090 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB0A0 (PANTHERLAKE)
[04:36:28] [PASSED] 0xB0B0 (PANTHERLAKE)
[04:36:28] [PASSED] 0xFD80 (PANTHERLAKE)
[04:36:28] [PASSED] 0xFD81 (PANTHERLAKE)
[04:36:28] [PASSED] 0xD740 (NOVALAKE_S)
[04:36:28] [PASSED] 0xD741 (NOVALAKE_S)
[04:36:28] [PASSED] 0xD742 (NOVALAKE_S)
[04:36:28] [PASSED] 0xD743 (NOVALAKE_S)
[04:36:28] [PASSED] 0xD745 (NOVALAKE_S)
[04:36:28] [PASSED] 0xD74A (NOVALAKE_S)
[04:36:28] [PASSED] 0xD74B (NOVALAKE_S)
[04:36:28] [PASSED] 0x674C (CRESCENTISLAND)
[04:36:28] [PASSED] 0x674D (CRESCENTISLAND)
[04:36:28] [PASSED] 0x674E (CRESCENTISLAND)
[04:36:28] [PASSED] 0x674F (CRESCENTISLAND)
[04:36:28] [PASSED] 0x6750 (CRESCENTISLAND)
[04:36:28] [PASSED] 0xD750 (NOVALAKE_P)
[04:36:28] [PASSED] 0xD751 (NOVALAKE_P)
[04:36:28] [PASSED] 0xD752 (NOVALAKE_P)
[04:36:28] [PASSED] 0xD753 (NOVALAKE_P)
[04:36:28] [PASSED] 0xD754 (NOVALAKE_P)
[04:36:28] [PASSED] 0xD755 (NOVALAKE_P)
[04:36:28] [PASSED] 0xD756 (NOVALAKE_P)
[04:36:28] [PASSED] 0xD757 (NOVALAKE_P)
[04:36:28] [PASSED] 0xD75F (NOVALAKE_P)
[04:36:28] =============== [PASSED] check_platform_desc ===============
[04:36:28] ===================== [PASSED] xe_pci ======================
[04:36:28] ============= xe_rtp_tables_test (4 subtests) ==============
[04:36:28] ================== xe_rtp_table_gt_test  ===================
[04:36:28] [PASSED] gt_was/14011060649
[04:36:28] [PASSED] gt_was/14011059788
[04:36:28] [PASSED] gt_was/14015795083
[04:36:28] [PASSED] gt_was/16021867713
[04:36:28] [PASSED] gt_was/14019449301
[04:36:28] [PASSED] gt_was/16028005424
[04:36:28] [PASSED] gt_was/14026578760
[04:36:28] [PASSED] gt_was/1409420604
[04:36:28] [PASSED] gt_was/1408615072
[04:36:28] [PASSED] gt_was/22010523718
[04:36:28] [PASSED] gt_was/14011006942
[04:36:28] [PASSED] gt_was/14014830051
[04:36:28] [PASSED] gt_was/18018781329
[04:36:28] [PASSED] gt_was/1509235366
[04:36:28] [PASSED] gt_was/18018781329
[04:36:28] [PASSED] gt_was/16016694945
[04:36:28] [PASSED] gt_was/14018575942
[04:36:28] [PASSED] gt_was/22016670082
[04:36:28] [PASSED] gt_was/22016670082
[04:36:28] [PASSED] gt_was/14017421178
[04:36:28] [PASSED] gt_was/16025250150
[04:36:28] [PASSED] gt_was/14021871409
[04:36:28] [PASSED] gt_was/16021865536
[04:36:28] [PASSED] gt_was/14021486841
[04:36:28] [PASSED] gt_was/14025160223
[04:36:28] [PASSED] gt_was/14026144927, 16029437861, 14026127056
[04:36:28] [PASSED] gt_was/14025635424
[04:36:28] [PASSED] gt_was/16028005424
[04:36:28] ============== [PASSED] xe_rtp_table_gt_test ===============
[04:36:28] ================== xe_rtp_table_gt_test  ===================
[04:36:28] [PASSED] gt_tunings/Tuning: Blend Fill Caching Optimization Disable
[04:36:28] [PASSED] gt_tunings/Tuning: 32B Access Enable
[04:36:28] [PASSED] gt_tunings/Tuning: L3 cache
[04:36:28] [PASSED] gt_tunings/Tuning: L3 cache - media
[04:36:28] [PASSED] gt_tunings/Tuning: Compression Overfetch
[04:36:28] [PASSED] gt_tunings/Tuning: Compression Overfetch - media
[04:36:28] [PASSED] gt_tunings/Tuning: Enable compressible partial write overfetch in L3
[04:36:28] [PASSED] gt_tunings/Tuning: Enable compressible partial write overfetch in L3 - media
[04:36:28] [PASSED] gt_tunings/Tuning: L2 Overfetch Compressible Only
[04:36:28] [PASSED] gt_tunings/Tuning: L2 Overfetch Compressible Only - media
[04:36:28] [PASSED] gt_tunings/Tuning: Stateless compression control
[04:36:28] [PASSED] gt_tunings/Tuning: Stateless compression control - media
[04:36:28] [PASSED] gt_tunings/Tuning: L3 RW flush all Cache
[04:36:28] [PASSED] gt_tunings/Tuning: L3 RW flush all cache - media
[04:36:28] [PASSED] gt_tunings/Tuning: Set STLB Bank Hash Mode to 4KB
[04:36:28] ============== [PASSED] xe_rtp_table_gt_test ===============
[04:36:28] ================== xe_rtp_table_oob_test  ==================
[04:36:28] [PASSED] oob_was/1607983814
[04:36:28] [PASSED] oob_was/16010904313
[04:36:28] [PASSED] oob_was/18022495364
[04:36:28] [PASSED] oob_was/22012773006
[04:36:28] [PASSED] oob_was/14014475959
[04:36:28] [PASSED] oob_was/22011391025
[04:36:28] [PASSED] oob_was/22012727170
[04:36:28] [PASSED] oob_was/22012727685
[04:36:28] [PASSED] oob_was/22016596838
[04:36:28] [PASSED] oob_was/18020744125
[04:36:28] [PASSED] oob_was/1409600907
[04:36:28] [PASSED] oob_was/22014953428
[04:36:28] [PASSED] oob_was/16017236439
[04:36:28] [PASSED] oob_was/14019821291
[04:36:28] [PASSED] oob_was/14015076503
[04:36:28] [PASSED] oob_was/14018913170
[04:36:28] [PASSED] oob_was/14018094691
[04:36:28] [PASSED] oob_was/18024947630
[04:36:28] [PASSED] oob_was/16022287689
[04:36:28] [PASSED] oob_was/13011645652
[04:36:28] [PASSED] oob_was/14022293748
[04:36:28] [PASSED] oob_was/22019794406
[04:36:28] [PASSED] oob_was/22019338487
[04:36:28] [PASSED] oob_was/16023588340
[04:36:28] [PASSED] oob_was/14019789679
[04:36:28] [PASSED] oob_was/14022866841
[04:36:28] [PASSED] oob_was/16021333562
[04:36:28] [PASSED] oob_was/14016712196
[04:36:28] [PASSED] oob_was/14015568240
[04:36:28] [PASSED] oob_was/18013179988
[04:36:28] [PASSED] oob_was/1508761755
[04:36:28] [PASSED] oob_was/16023105232
[04:36:28] [PASSED] oob_was/16026508708
[04:36:28] [PASSED] oob_was/14020001231
[04:36:28] [PASSED] oob_was/16023683509
[04:36:28] [PASSED] oob_was/14025515070
[04:36:28] [PASSED] oob_was/15015404425_disable
[04:36:28] [PASSED] oob_was/16026007364
[04:36:28] [PASSED] oob_was/14020316580
[04:36:28] [PASSED] oob_was/14025883347
[04:36:28] [PASSED] oob_was/16029380221
[04:36:28] ============== [PASSED] xe_rtp_table_oob_test ==============
[04:36:28] ================ xe_rtp_table_dev_oob_test  ================
[04:36:28] [PASSED] device_oob_was/22010954014
[04:36:28] [PASSED] device_oob_was/15015404425
[04:36:28] [PASSED] device_oob_was/22019338487_display
[04:36:28] [PASSED] device_oob_was/14022085890
[04:36:28] [PASSED] device_oob_was/14026539277
[04:36:28] [PASSED] device_oob_was/14026633728
[04:36:28] [PASSED] device_oob_was/14026746987
[04:36:28] [PASSED] device_oob_was/14026779378
[04:36:28] ============ [PASSED] xe_rtp_table_dev_oob_test ============
[04:36:28] =============== [PASSED] xe_rtp_tables_test ================
[04:36:28] =================== xe_rtp (3 subtests) ====================
[04:36:28] =================== xe_rtp_rules_tests  ====================
[04:36:28] [PASSED] no
[04:36:28] [PASSED] yes
[04:36:28] [PASSED] no-and-no
[04:36:28] [PASSED] no-and-yes
[04:36:28] [PASSED] yes-and-no
[04:36:28] [PASSED] yes-and-yes
[04:36:28] [PASSED] no-or-no
[04:36:28] [PASSED] no-or-yes
[04:36:28] [PASSED] yes-or-no
[04:36:28] [PASSED] yes-or-yes
[04:36:28] [PASSED] no-yes-or-yes-no
[04:36:28] [PASSED] no-yes-or-yes-yes
[04:36:28] [PASSED] yes-yes-or-no-yes
[04:36:28] [PASSED] yes-yes-or-yes-yes
[04:36:28] [PASSED] no-no-or-yes-or-no
[04:36:28] [PASSED] or
[04:36:28] [PASSED] or-yes
[04:36:28] [PASSED] or-no
[04:36:28] [PASSED] yes-or
[04:36:28] [PASSED] no-or
[04:36:28] [PASSED] no-or-or-yes
[04:36:28] [PASSED] yes-or-or-no
[04:36:28] [PASSED] no-or-or-no
[04:36:28] [PASSED] missing-context-engine-class
[04:36:28] [PASSED] missing-context-engine-class-or-yes
[04:36:28] [PASSED] missing-context-engine-class-or-or-yes
[04:36:28] =============== [PASSED] xe_rtp_rules_tests ================
[04:36:28] =============== xe_rtp_process_to_sr_tests  ================
[04:36:28] [PASSED] coalesce-same-reg
[04:36:28] [PASSED] no-match-no-add
[04:36:28] [PASSED] two-regs-two-entries
[04:36:28] [PASSED] clr-one-set-other
[04:36:28] [PASSED] set-field
[04:36:28] [PASSED] conflict-duplicate
[04:36:28] [PASSED] conflict-not-disjoint
[04:36:28] [PASSED] conflict-reg-type
[04:36:28] [PASSED] bad-mcr-reg-forced-to-regular
[04:36:28] [PASSED] bad-regular-reg-forced-to-mcr
[04:36:28] =========== [PASSED] xe_rtp_process_to_sr_tests ============
[04:36:28] ================== xe_rtp_process_tests  ===================
[04:36:28] [PASSED] active1
[04:36:28] [PASSED] active2
[04:36:28] [PASSED] active-inactive
[04:36:28] [PASSED] inactive-active
[04:36:28] [PASSED] inactive-active-inactive
[04:36:28] [PASSED] inactive-inactive-inactive
[04:36:28] ============== [PASSED] xe_rtp_process_tests ===============
[04:36:28] ===================== [PASSED] xe_rtp ======================
[04:36:28] ==================== xe_wa (1 subtest) =====================
[04:36:28] ======================== xe_wa_gt  =========================
[04:36:28] [PASSED] TIGERLAKE B0
[04:36:28] [PASSED] DG1 A0
[04:36:28] [PASSED] DG1 B0
[04:36:28] [PASSED] ALDERLAKE_S A0
[04:36:28] [PASSED] ALDERLAKE_S B0
[04:36:28] [PASSED] ALDERLAKE_S C0
[04:36:28] [PASSED] ALDERLAKE_S D0
[04:36:28] [PASSED] ALDERLAKE_P A0
[04:36:28] [PASSED] ALDERLAKE_P B0
[04:36:28] [PASSED] ALDERLAKE_P C0
[04:36:28] [PASSED] ALDERLAKE_S RPLS D0
[04:36:28] [PASSED] ALDERLAKE_P RPLU E0
[04:36:28] [PASSED] DG2 G10 C0
[04:36:28] [PASSED] DG2 G11 B1
[04:36:28] [PASSED] DG2 G12 A1
[04:36:28] [PASSED] METEORLAKE 12.70(Xe_LPG) A0 13.00(Xe_LPM+) A0
[04:36:28] [PASSED] METEORLAKE 12.71(Xe_LPG) A0 13.00(Xe_LPM+) A0
[04:36:28] [PASSED] METEORLAKE 12.74(Xe_LPG+) A0 13.00(Xe_LPM+) A0
[04:36:28] [PASSED] LUNARLAKE 20.04(Xe2_LPG) A0 20.00(Xe2_LPM) A0
[04:36:28] [PASSED] LUNARLAKE 20.04(Xe2_LPG) B0 20.00(Xe2_LPM) A0
[04:36:28] [PASSED] BATTLEMAGE 20.01(Xe2_HPG) A0 13.01(Xe2_HPM) A1
[04:36:28] [PASSED] PANTHERLAKE 30.00(Xe3_LPG) A0 30.00(Xe3_LPM) A0
[04:36:28] ==================== [PASSED] xe_wa_gt =====================
[04:36:28] ====================== [PASSED] xe_wa ======================
[04:36:28] ============================================================
[04:36:28] Testing complete. Ran 717 tests: passed: 699, skipped: 18
[04:36:28] Elapsed time: 36.166s total, 4.286s configuring, 31.215s building, 0.640s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/tests/.kunitconfig [04:36:28] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:

$ make ARCH=um O=.kunit olddefconfig
[04:36:30] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[04:36:54] Starting KUnit Kernel (1/1)...
[04:36:54] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[04:36:54] ============ drm_test_pick_cmdline (2 subtests) ============
[04:36:54] [PASSED] drm_test_pick_cmdline_res_1920_1080_60
[04:36:54] =============== drm_test_pick_cmdline_named  ===============
[04:36:54] [PASSED] NTSC
[04:36:54] [PASSED] NTSC-J
[04:36:54] [PASSED] PAL
[04:36:54] [PASSED] PAL-M
[04:36:54] =========== [PASSED] drm_test_pick_cmdline_named ===========
[04:36:54] ============== [PASSED] drm_test_pick_cmdline ==============
[04:36:54] == drm_test_atomic_get_connector_for_encoder (1 subtest) ===
[04:36:54] [PASSED] drm_test_drm_atomic_get_connector_for_encoder
[04:36:54] ==== [PASSED] drm_test_atomic_get_connector_for_encoder ====
[04:36:54] =========== drm_validate_clone_mode (2 subtests) ===========
[04:36:54] ============== drm_test_check_in_clone_mode  ===============
[04:36:54] [PASSED] in_clone_mode
[04:36:54] [PASSED] not_in_clone_mode
[04:36:54] ========== [PASSED] drm_test_check_in_clone_mode ===========
[04:36:54] =============== drm_test_check_valid_clones  ===============
[04:36:54] [PASSED] not_in_clone_mode
[04:36:54] [PASSED] valid_clone
[04:36:54] [PASSED] invalid_clone
[04:36:54] =========== [PASSED] drm_test_check_valid_clones ===========
[04:36:54] ============= [PASSED] drm_validate_clone_mode =============
[04:36:54] ============= drm_validate_modeset (1 subtest) =============
[04:36:54] [PASSED] drm_test_check_connector_changed_modeset
[04:36:54] ============== [PASSED] drm_validate_modeset ===============
[04:36:54] ====== drm_test_bridge_get_current_state (2 subtests) ======
[04:36:54] [PASSED] drm_test_drm_bridge_get_current_state_atomic
[04:36:54] [PASSED] drm_test_drm_bridge_get_current_state_legacy
[04:36:54] ======== [PASSED] drm_test_bridge_get_current_state ========
[04:36:54] ====== drm_test_bridge_helper_reset_crtc (4 subtests) ======
[04:36:54] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic
[04:36:54] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic_disabled
[04:36:54] [PASSED] drm_test_drm_bridge_helper_reset_crtc_legacy
[04:36:54] [PASSED] drm_test_drm_bridge_helper_hdmi_output_bus_fmts
[04:36:54] ======== [PASSED] drm_test_bridge_helper_reset_crtc ========
[04:36:54] ============== drm_bridge_alloc (2 subtests) ===============
[04:36:54] [PASSED] drm_test_drm_bridge_alloc_basic
[04:36:54] [PASSED] drm_test_drm_bridge_alloc_get_put
[04:36:54] ================ [PASSED] drm_bridge_alloc =================
[04:36:54] ============= drm_bridge_bus_fmt (5 subtests) ==============
[04:36:54] [PASSED] drm_test_bridge_rgb_yuv_rgb
[04:36:54] [PASSED] drm_test_bridge_must_convert_to_yuv444
[04:36:54] [PASSED] drm_test_bridge_hdmi_auto_rgb
[04:36:54] [PASSED] drm_test_bridge_auto_first
[04:36:54] [PASSED] drm_test_bridge_rgb_yuv_no_path
[04:36:54] =============== [PASSED] drm_bridge_bus_fmt ================
[04:36:54] ============= drm_cmdline_parser (40 subtests) =============
[04:36:54] [PASSED] drm_test_cmdline_force_d_only
[04:36:54] [PASSED] drm_test_cmdline_force_D_only_dvi
[04:36:54] [PASSED] drm_test_cmdline_force_D_only_hdmi
[04:36:54] [PASSED] drm_test_cmdline_force_D_only_not_digital
[04:36:54] [PASSED] drm_test_cmdline_force_e_only
[04:36:54] [PASSED] drm_test_cmdline_res
[04:36:54] [PASSED] drm_test_cmdline_res_vesa
[04:36:54] [PASSED] drm_test_cmdline_res_vesa_rblank
[04:36:54] [PASSED] drm_test_cmdline_res_rblank
[04:36:54] [PASSED] drm_test_cmdline_res_bpp
[04:36:54] [PASSED] drm_test_cmdline_res_refresh
[04:36:54] [PASSED] drm_test_cmdline_res_bpp_refresh
[04:36:54] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced
[04:36:54] [PASSED] drm_test_cmdline_res_bpp_refresh_margins
[04:36:54] [PASSED] drm_test_cmdline_res_bpp_refresh_force_off
[04:36:54] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on
[04:36:54] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_analog
[04:36:54] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_digital
[04:36:54] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced_margins_force_on
[04:36:54] [PASSED] drm_test_cmdline_res_margins_force_on
[04:36:54] [PASSED] drm_test_cmdline_res_vesa_margins
[04:36:54] [PASSED] drm_test_cmdline_name
[04:36:54] [PASSED] drm_test_cmdline_name_bpp
[04:36:54] [PASSED] drm_test_cmdline_name_option
[04:36:54] [PASSED] drm_test_cmdline_name_bpp_option
[04:36:54] [PASSED] drm_test_cmdline_rotate_0
[04:36:54] [PASSED] drm_test_cmdline_rotate_90
[04:36:54] [PASSED] drm_test_cmdline_rotate_180
[04:36:54] [PASSED] drm_test_cmdline_rotate_270
[04:36:54] [PASSED] drm_test_cmdline_hmirror
[04:36:54] [PASSED] drm_test_cmdline_vmirror
[04:36:54] [PASSED] drm_test_cmdline_margin_options
[04:36:54] [PASSED] drm_test_cmdline_multiple_options
[04:36:54] [PASSED] drm_test_cmdline_bpp_extra_and_option
[04:36:54] [PASSED] drm_test_cmdline_extra_and_option
[04:36:54] [PASSED] drm_test_cmdline_freestanding_options
[04:36:54] [PASSED] drm_test_cmdline_freestanding_force_e_and_options
[04:36:54] [PASSED] drm_test_cmdline_panel_orientation
[04:36:54] ================ drm_test_cmdline_invalid  =================
[04:36:54] [PASSED] margin_only
[04:36:54] [PASSED] interlace_only
[04:36:54] [PASSED] res_missing_x
[04:36:54] [PASSED] res_missing_y
[04:36:54] [PASSED] res_bad_y
[04:36:54] [PASSED] res_missing_y_bpp
[04:36:54] [PASSED] res_bad_bpp
[04:36:54] [PASSED] res_bad_refresh
[04:36:54] [PASSED] res_bpp_refresh_force_on_off
[04:36:54] [PASSED] res_invalid_mode
[04:36:54] [PASSED] res_bpp_wrong_place_mode
[04:36:54] [PASSED] name_bpp_refresh
[04:36:54] [PASSED] name_refresh
[04:36:54] [PASSED] name_refresh_wrong_mode
[04:36:54] [PASSED] name_refresh_invalid_mode
[04:36:54] [PASSED] rotate_multiple
[04:36:54] [PASSED] rotate_invalid_val
[04:36:54] [PASSED] rotate_truncated
[04:36:54] [PASSED] invalid_option
[04:36:54] [PASSED] invalid_tv_option
[04:36:54] [PASSED] truncated_tv_option
[04:36:54] ============ [PASSED] drm_test_cmdline_invalid =============
[04:36:54] =============== drm_test_cmdline_tv_options  ===============
[04:36:54] [PASSED] NTSC
[04:36:54] [PASSED] NTSC_443
[04:36:54] [PASSED] NTSC_J
[04:36:54] [PASSED] PAL
[04:36:54] [PASSED] PAL_M
[04:36:54] [PASSED] PAL_N
[04:36:54] [PASSED] SECAM
[04:36:54] [PASSED] MONO_525
[04:36:54] [PASSED] MONO_625
[04:36:54] =========== [PASSED] drm_test_cmdline_tv_options ===========
[04:36:54] =============== [PASSED] drm_cmdline_parser ================
[04:36:54] ========== drmm_connector_hdmi_init (20 subtests) ==========
[04:36:54] [PASSED] drm_test_connector_hdmi_init_valid
[04:36:54] [PASSED] drm_test_connector_hdmi_init_bpc_8
[04:36:54] [PASSED] drm_test_connector_hdmi_init_bpc_10
[04:36:54] [PASSED] drm_test_connector_hdmi_init_bpc_12
[04:36:54] [PASSED] drm_test_connector_hdmi_init_bpc_invalid
[04:36:54] [PASSED] drm_test_connector_hdmi_init_bpc_null
[04:36:54] [PASSED] drm_test_connector_hdmi_init_formats_empty
[04:36:54] [PASSED] drm_test_connector_hdmi_init_formats_no_rgb
[04:36:54] === drm_test_connector_hdmi_init_formats_yuv420_allowed  ===
[04:36:54] [PASSED] supported_formats=0x9 yuv420_allowed=1
[04:36:54] [PASSED] supported_formats=0x9 yuv420_allowed=0
[04:36:54] [PASSED] supported_formats=0x5 yuv420_allowed=1
[04:36:54] [PASSED] supported_formats=0x5 yuv420_allowed=0
[04:36:54] === [PASSED] drm_test_connector_hdmi_init_formats_yuv420_allowed ===
[04:36:54] [PASSED] drm_test_connector_hdmi_init_null_ddc
[04:36:54] [PASSED] drm_test_connector_hdmi_init_null_product
[04:36:54] [PASSED] drm_test_connector_hdmi_init_null_vendor
[04:36:54] [PASSED] drm_test_connector_hdmi_init_product_length_exact
[04:36:54] [PASSED] drm_test_connector_hdmi_init_product_length_too_long
[04:36:54] [PASSED] drm_test_connector_hdmi_init_product_valid
[04:36:54] [PASSED] drm_test_connector_hdmi_init_vendor_length_exact
[04:36:54] [PASSED] drm_test_connector_hdmi_init_vendor_length_too_long
[04:36:54] [PASSED] drm_test_connector_hdmi_init_vendor_valid
[04:36:54] ========= drm_test_connector_hdmi_init_type_valid  =========
[04:36:54] [PASSED] HDMI-A
[04:36:54] [PASSED] HDMI-B
[04:36:54] ===== [PASSED] drm_test_connector_hdmi_init_type_valid =====
[04:36:54] ======== drm_test_connector_hdmi_init_type_invalid  ========
[04:36:54] [PASSED] Unknown
[04:36:54] [PASSED] VGA
[04:36:54] [PASSED] DVI-I
[04:36:54] [PASSED] DVI-D
[04:36:54] [PASSED] DVI-A
[04:36:54] [PASSED] Composite
[04:36:54] [PASSED] SVIDEO
[04:36:54] [PASSED] LVDS
[04:36:54] [PASSED] Component
[04:36:54] [PASSED] DIN
[04:36:54] [PASSED] DP
[04:36:54] [PASSED] TV
[04:36:54] [PASSED] eDP
[04:36:54] [PASSED] Virtual
[04:36:54] [PASSED] DSI
[04:36:54] [PASSED] DPI
[04:36:54] [PASSED] Writeback
[04:36:54] [PASSED] SPI
[04:36:54] [PASSED] USB
[04:36:54] ==== [PASSED] drm_test_connector_hdmi_init_type_invalid ====
[04:36:54] ============ [PASSED] drmm_connector_hdmi_init =============
[04:36:54] ============= drmm_connector_init (3 subtests) =============
[04:36:54] [PASSED] drm_test_drmm_connector_init
[04:36:54] [PASSED] drm_test_drmm_connector_init_null_ddc
[04:36:54] ========= drm_test_drmm_connector_init_type_valid  =========
[04:36:54] [PASSED] Unknown
[04:36:54] [PASSED] VGA
[04:36:54] [PASSED] DVI-I
[04:36:54] [PASSED] DVI-D
[04:36:54] [PASSED] DVI-A
[04:36:54] [PASSED] Composite
[04:36:54] [PASSED] SVIDEO
[04:36:54] [PASSED] LVDS
[04:36:54] [PASSED] Component
[04:36:54] [PASSED] DIN
[04:36:54] [PASSED] DP
[04:36:54] [PASSED] HDMI-A
[04:36:54] [PASSED] HDMI-B
[04:36:54] [PASSED] TV
[04:36:54] [PASSED] eDP
[04:36:54] [PASSED] Virtual
[04:36:54] [PASSED] DSI
[04:36:54] [PASSED] DPI
[04:36:54] [PASSED] Writeback
[04:36:54] [PASSED] SPI
[04:36:54] [PASSED] USB
[04:36:54] ===== [PASSED] drm_test_drmm_connector_init_type_valid =====
[04:36:54] =============== [PASSED] drmm_connector_init ===============
[04:36:54] ========= drm_connector_dynamic_init (6 subtests) ==========
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_init
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_init_null_ddc
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_init_not_added
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_init_properties
[04:36:54] ===== drm_test_drm_connector_dynamic_init_type_valid  ======
[04:36:54] [PASSED] Unknown
[04:36:54] [PASSED] VGA
[04:36:54] [PASSED] DVI-I
[04:36:54] [PASSED] DVI-D
[04:36:54] [PASSED] DVI-A
[04:36:54] [PASSED] Composite
[04:36:54] [PASSED] SVIDEO
[04:36:54] [PASSED] LVDS
[04:36:54] [PASSED] Component
[04:36:54] [PASSED] DIN
[04:36:54] [PASSED] DP
[04:36:54] [PASSED] HDMI-A
[04:36:54] [PASSED] HDMI-B
[04:36:54] [PASSED] TV
[04:36:54] [PASSED] eDP
[04:36:54] [PASSED] Virtual
[04:36:54] [PASSED] DSI
[04:36:54] [PASSED] DPI
[04:36:54] [PASSED] Writeback
[04:36:54] [PASSED] SPI
[04:36:54] [PASSED] USB
[04:36:54] = [PASSED] drm_test_drm_connector_dynamic_init_type_valid ==
[04:36:54] ======== drm_test_drm_connector_dynamic_init_name  =========
[04:36:54] [PASSED] Unknown
[04:36:54] [PASSED] VGA
[04:36:54] [PASSED] DVI-I
[04:36:54] [PASSED] DVI-D
[04:36:54] [PASSED] DVI-A
[04:36:54] [PASSED] Composite
[04:36:54] [PASSED] SVIDEO
[04:36:54] [PASSED] LVDS
[04:36:54] [PASSED] Component
[04:36:54] [PASSED] DIN
[04:36:54] [PASSED] DP
[04:36:54] [PASSED] HDMI-A
[04:36:54] [PASSED] HDMI-B
[04:36:54] [PASSED] TV
[04:36:54] [PASSED] eDP
[04:36:54] [PASSED] Virtual
[04:36:54] [PASSED] DSI
[04:36:54] [PASSED] DPI
[04:36:54] [PASSED] Writeback
[04:36:54] [PASSED] SPI
[04:36:54] [PASSED] USB
[04:36:54] ==== [PASSED] drm_test_drm_connector_dynamic_init_name =====
[04:36:54] =========== [PASSED] drm_connector_dynamic_init ============
[04:36:54] ==== drm_connector_dynamic_register_early (4 subtests) =====
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_early_on_list
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_early_defer
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_early_no_init
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_early_no_mode_object
[04:36:54] ====== [PASSED] drm_connector_dynamic_register_early =======
[04:36:54] ======= drm_connector_dynamic_register (7 subtests) ========
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_on_list
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_no_defer
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_no_init
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_mode_object
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_sysfs
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_sysfs_name
[04:36:54] [PASSED] drm_test_drm_connector_dynamic_register_debugfs
[04:36:54] ========= [PASSED] drm_connector_dynamic_register ==========
[04:36:54] = drm_connector_attach_broadcast_rgb_property (2 subtests) =
[04:36:54] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property
[04:36:54] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector
[04:36:54] === [PASSED] drm_connector_attach_broadcast_rgb_property ===
[04:36:54] ========== drm_get_tv_mode_from_name (2 subtests) ==========
[04:36:54] ========== drm_test_get_tv_mode_from_name_valid  ===========
[04:36:54] [PASSED] NTSC
[04:36:54] [PASSED] NTSC-443
[04:36:54] [PASSED] NTSC-J
[04:36:54] [PASSED] PAL
[04:36:54] [PASSED] PAL-M
[04:36:54] [PASSED] PAL-N
[04:36:54] [PASSED] SECAM
[04:36:54] [PASSED] Mono
[04:36:54] ====== [PASSED] drm_test_get_tv_mode_from_name_valid =======
[04:36:54] [PASSED] drm_test_get_tv_mode_from_name_truncated
[04:36:54] ============ [PASSED] drm_get_tv_mode_from_name ============
[04:36:54] = drm_test_connector_hdmi_compute_mode_clock (12 subtests) =
[04:36:54] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb
[04:36:54] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc
[04:36:54] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1
[04:36:54] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc
[04:36:54] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1
[04:36:54] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_double
[04:36:54] = drm_test_connector_hdmi_compute_mode_clock_yuv420_valid  =
[04:36:54] [PASSED] VIC 96
[04:36:54] [PASSED] VIC 97
[04:36:54] [PASSED] VIC 101
[04:36:54] [PASSED] VIC 102
[04:36:54] [PASSED] VIC 106
[04:36:54] [PASSED] VIC 107
[04:36:54] === [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_valid ===
[04:36:54] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc
[04:36:54] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc
[04:36:54] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc
[04:36:54] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc
[04:36:54] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc
[04:36:54] === [PASSED] drm_test_connector_hdmi_compute_mode_clock ====
[04:36:54] == drm_hdmi_connector_get_broadcast_rgb_name (2 subtests) ==
[04:36:54] === drm_test_drm_hdmi_connector_get_broadcast_rgb_name  ====
[04:36:54] [PASSED] Automatic
[04:36:54] [PASSED] Full
[04:36:54] [PASSED] Limited 16:235
[04:36:54] === [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name ===
[04:36:54] [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid
[04:36:54] ==== [PASSED] drm_hdmi_connector_get_broadcast_rgb_name ====
[04:36:54] == drm_hdmi_connector_get_output_format_name (2 subtests) ==
[04:36:54] === drm_test_drm_hdmi_connector_get_output_format_name  ====
[04:36:54] [PASSED] RGB
[04:36:54] [PASSED] YUV 4:2:0
[04:36:54] [PASSED] YUV 4:2:2
[04:36:54] [PASSED] YUV 4:4:4
[04:36:54] === [PASSED] drm_test_drm_hdmi_connector_get_output_format_name ===
[04:36:54] [PASSED] drm_test_drm_hdmi_connector_get_output_format_name_invalid
[04:36:54] ==== [PASSED] drm_hdmi_connector_get_output_format_name ====
[04:36:54] ============= drm_damage_helper (21 subtests) ==============
[04:36:54] [PASSED] drm_test_damage_iter_no_damage
[04:36:54] [PASSED] drm_test_damage_iter_no_damage_fractional_src
[04:36:54] [PASSED] drm_test_damage_iter_no_damage_src_moved
[04:36:54] [PASSED] drm_test_damage_iter_no_damage_fractional_src_moved
[04:36:54] [PASSED] drm_test_damage_iter_no_damage_not_visible
[04:36:54] [PASSED] drm_test_damage_iter_no_damage_no_crtc
[04:36:54] [PASSED] drm_test_damage_iter_no_damage_no_fb
[04:36:54] [PASSED] drm_test_damage_iter_simple_damage
[04:36:54] [PASSED] drm_test_damage_iter_single_damage
[04:36:54] [PASSED] drm_test_damage_iter_single_damage_intersect_src
[04:36:54] [PASSED] drm_test_damage_iter_single_damage_outside_src
[04:36:54] [PASSED] drm_test_damage_iter_single_damage_fractional_src
[04:36:54] [PASSED] drm_test_damage_iter_single_damage_intersect_fractional_src
[04:36:54] [PASSED] drm_test_damage_iter_single_damage_outside_fractional_src
[04:36:54] [PASSED] drm_test_damage_iter_single_damage_src_moved
[04:36:54] [PASSED] drm_test_damage_iter_single_damage_fractional_src_moved
[04:36:54] [PASSED] drm_test_damage_iter_damage
[04:36:54] [PASSED] drm_test_damage_iter_damage_one_intersect
[04:36:54] [PASSED] drm_test_damage_iter_damage_one_outside
[04:36:54] [PASSED] drm_test_damage_iter_damage_src_moved
[04:36:54] [PASSED] drm_test_damage_iter_damage_not_visible
[04:36:54] ================ [PASSED] drm_damage_helper ================
[04:36:54] ============== drm_dp_mst_helper (3 subtests) ==============
[04:36:54] ============== drm_test_dp_mst_calc_pbn_mode  ==============
[04:36:54] [PASSED] Clock 154000 BPP 30 DSC disabled
[04:36:54] [PASSED] Clock 234000 BPP 30 DSC disabled
[04:36:54] [PASSED] Clock 297000 BPP 24 DSC disabled
[04:36:54] [PASSED] Clock 332880 BPP 24 DSC enabled
[04:36:54] [PASSED] Clock 324540 BPP 24 DSC enabled
[04:36:54] ========== [PASSED] drm_test_dp_mst_calc_pbn_mode ==========
[04:36:54] ============== drm_test_dp_mst_calc_pbn_div  ===============
[04:36:54] [PASSED] Link rate 2000000 lane count 4
[04:36:54] [PASSED] Link rate 2000000 lane count 2
[04:36:54] [PASSED] Link rate 2000000 lane count 1
[04:36:54] [PASSED] Link rate 1350000 lane count 4
[04:36:54] [PASSED] Link rate 1350000 lane count 2
[04:36:54] [PASSED] Link rate 1350000 lane count 1
[04:36:54] [PASSED] Link rate 1000000 lane count 4
[04:36:54] [PASSED] Link rate 1000000 lane count 2
[04:36:54] [PASSED] Link rate 1000000 lane count 1
[04:36:54] [PASSED] Link rate 810000 lane count 4
[04:36:54] [PASSED] Link rate 810000 lane count 2
[04:36:54] [PASSED] Link rate 810000 lane count 1
[04:36:54] [PASSED] Link rate 540000 lane count 4
[04:36:54] [PASSED] Link rate 540000 lane count 2
[04:36:54] [PASSED] Link rate 540000 lane count 1
[04:36:54] [PASSED] Link rate 270000 lane count 4
[04:36:54] [PASSED] Link rate 270000 lane count 2
[04:36:54] [PASSED] Link rate 270000 lane count 1
[04:36:54] [PASSED] Link rate 162000 lane count 4
[04:36:54] [PASSED] Link rate 162000 lane count 2
[04:36:54] [PASSED] Link rate 162000 lane count 1
[04:36:54] ========== [PASSED] drm_test_dp_mst_calc_pbn_div ===========
[04:36:54] ========= drm_test_dp_mst_sideband_msg_req_decode  =========
[04:36:54] [PASSED] DP_ENUM_PATH_RESOURCES with port number
[04:36:54] [PASSED] DP_POWER_UP_PHY with port number
[04:36:54] [PASSED] DP_POWER_DOWN_PHY with port number
[04:36:54] [PASSED] DP_ALLOCATE_PAYLOAD with SDP stream sinks
[04:36:54] [PASSED] DP_ALLOCATE_PAYLOAD with port number
[04:36:54] [PASSED] DP_ALLOCATE_PAYLOAD with VCPI
[04:36:54] [PASSED] DP_ALLOCATE_PAYLOAD with PBN
[04:36:54] [PASSED] DP_QUERY_PAYLOAD with port number
[04:36:54] [PASSED] DP_QUERY_PAYLOAD with VCPI
[04:36:54] [PASSED] DP_REMOTE_DPCD_READ with port number
[04:36:54] [PASSED] DP_REMOTE_DPCD_READ with DPCD address
[04:36:54] [PASSED] DP_REMOTE_DPCD_READ with max number of bytes
[04:36:54] [PASSED] DP_REMOTE_DPCD_WRITE with port number
[04:36:54] [PASSED] DP_REMOTE_DPCD_WRITE with DPCD address
[04:36:54] [PASSED] DP_REMOTE_DPCD_WRITE with data array
[04:36:54] [PASSED] DP_REMOTE_I2C_READ with port number
[04:36:54] [PASSED] DP_REMOTE_I2C_READ with I2C device ID
[04:36:54] [PASSED] DP_REMOTE_I2C_READ with transactions array
[04:36:54] [PASSED] DP_REMOTE_I2C_WRITE with port number
[04:36:54] [PASSED] DP_REMOTE_I2C_WRITE with I2C device ID
[04:36:54] [PASSED] DP_REMOTE_I2C_WRITE with data array
[04:36:54] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream ID
[04:36:54] [PASSED] DP_QUERY_STREAM_ENC_STATUS with client ID
[04:36:54] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream event
[04:36:54] [PASSED] DP_QUERY_STREAM_ENC_STATUS with valid stream event
[04:36:54] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream behavior
[04:36:54] [PASSED] DP_QUERY_STREAM_ENC_STATUS with a valid stream behavior
[04:36:54] ===== [PASSED] drm_test_dp_mst_sideband_msg_req_decode =====
[04:36:54] ================ [PASSED] drm_dp_mst_helper ================
[04:36:54] ================== drm_exec (7 subtests) ===================
[04:36:54] [PASSED] sanitycheck
[04:36:54] [PASSED] test_lock
[04:36:54] [PASSED] test_lock_unlock
[04:36:54] [PASSED] test_duplicates
[04:36:54] [PASSED] test_prepare
[04:36:54] [PASSED] test_prepare_array
[04:36:54] [PASSED] test_multiple_loops
[04:36:54] ==================== [PASSED] drm_exec =====================
[04:36:54] =========== drm_format_helper_test (17 subtests) ===========
[04:36:54] ============== drm_test_fb_xrgb8888_to_gray8  ==============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ========== [PASSED] drm_test_fb_xrgb8888_to_gray8 ==========
[04:36:54] ============= drm_test_fb_xrgb8888_to_rgb332  ==============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb332 ==========
[04:36:54] ============= drm_test_fb_xrgb8888_to_rgb565  ==============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb565 ==========
[04:36:54] ============ drm_test_fb_xrgb8888_to_xrgb1555  =============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ======== [PASSED] drm_test_fb_xrgb8888_to_xrgb1555 =========
[04:36:54] ============ drm_test_fb_xrgb8888_to_argb1555  =============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ======== [PASSED] drm_test_fb_xrgb8888_to_argb1555 =========
[04:36:54] ============ drm_test_fb_xrgb8888_to_rgba5551  =============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ======== [PASSED] drm_test_fb_xrgb8888_to_rgba5551 =========
[04:36:54] ============= drm_test_fb_xrgb8888_to_rgb888  ==============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb888 ==========
[04:36:54] ============= drm_test_fb_xrgb8888_to_bgr888  ==============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ========= [PASSED] drm_test_fb_xrgb8888_to_bgr888 ==========
[04:36:54] ============ drm_test_fb_xrgb8888_to_argb8888  =============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ======== [PASSED] drm_test_fb_xrgb8888_to_argb8888 =========
[04:36:54] =========== drm_test_fb_xrgb8888_to_xrgb2101010  ===========
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ======= [PASSED] drm_test_fb_xrgb8888_to_xrgb2101010 =======
[04:36:54] =========== drm_test_fb_xrgb8888_to_argb2101010  ===========
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ======= [PASSED] drm_test_fb_xrgb8888_to_argb2101010 =======
[04:36:54] ============== drm_test_fb_xrgb8888_to_mono  ===============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ========== [PASSED] drm_test_fb_xrgb8888_to_mono ===========
[04:36:54] ==================== drm_test_fb_swab  =====================
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ================ [PASSED] drm_test_fb_swab =================
[04:36:54] ============ drm_test_fb_xrgb8888_to_xbgr8888  =============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ======== [PASSED] drm_test_fb_xrgb8888_to_xbgr8888 =========
[04:36:54] ============ drm_test_fb_xrgb8888_to_abgr8888  =============
[04:36:54] [PASSED] single_pixel_source_buffer
[04:36:54] [PASSED] single_pixel_clip_rectangle
[04:36:54] [PASSED] well_known_colors
[04:36:54] [PASSED] destination_pitch
[04:36:54] ======== [PASSED] drm_test_fb_xrgb8888_to_abgr8888 =========
[04:36:54] ================= drm_test_fb_clip_offset  =================
[04:36:54] [PASSED] pass through
[04:36:54] [PASSED] horizontal offset
[04:36:54] [PASSED] vertical offset
[04:36:54] [PASSED] horizontal and vertical offset
[04:36:54] [PASSED] horizontal offset (custom pitch)
[04:36:54] [PASSED] vertical offset (custom pitch)
[04:36:54] [PASSED] horizontal and vertical offset (custom pitch)
[04:36:54] ============= [PASSED] drm_test_fb_clip_offset =============
[04:36:54] =================== drm_test_fb_memcpy  ====================
[04:36:54] [PASSED] single_pixel_source_buffer: XR24 little-endian (0x34325258)
[04:36:54] [PASSED] single_pixel_source_buffer: XRA8 little-endian (0x38415258)
[04:36:54] [PASSED] single_pixel_source_buffer: YU24 little-endian (0x34325559)
[04:36:54] [PASSED] single_pixel_clip_rectangle: XB24 little-endian (0x34324258)
[04:36:54] [PASSED] single_pixel_clip_rectangle: XRA8 little-endian (0x38415258)
[04:36:54] [PASSED] single_pixel_clip_rectangle: YU24 little-endian (0x34325559)
[04:36:54] [PASSED] well_known_colors: XB24 little-endian (0x34324258)
[04:36:54] [PASSED] well_known_colors: XRA8 little-endian (0x38415258)
[04:36:54] [PASSED] well_known_colors: YU24 little-endian (0x34325559)
[04:36:54] [PASSED] destination_pitch: XB24 little-endian (0x34324258)
[04:36:54] [PASSED] destination_pitch: XRA8 little-endian (0x38415258)
[04:36:54] [PASSED] destination_pitch: YU24 little-endian (0x34325559)
[04:36:54] =============== [PASSED] drm_test_fb_memcpy ================
[04:36:54] ============= [PASSED] drm_format_helper_test ==============
[04:36:54] ================= drm_format (18 subtests) =================
[04:36:54] [PASSED] drm_test_format_block_width_invalid
[04:36:54] [PASSED] drm_test_format_block_width_one_plane
[04:36:54] [PASSED] drm_test_format_block_width_two_plane
[04:36:54] [PASSED] drm_test_format_block_width_three_plane
[04:36:54] [PASSED] drm_test_format_block_width_tiled
[04:36:54] [PASSED] drm_test_format_block_height_invalid
[04:36:54] [PASSED] drm_test_format_block_height_one_plane
[04:36:54] [PASSED] drm_test_format_block_height_two_plane
[04:36:54] [PASSED] drm_test_format_block_height_three_plane
[04:36:54] [PASSED] drm_test_format_block_height_tiled
[04:36:54] [PASSED] drm_test_format_min_pitch_invalid
[04:36:54] [PASSED] drm_test_format_min_pitch_one_plane_8bpp
[04:36:54] [PASSED] drm_test_format_min_pitch_one_plane_16bpp
[04:36:54] [PASSED] drm_test_format_min_pitch_one_plane_24bpp
[04:36:54] [PASSED] drm_test_format_min_pitch_one_plane_32bpp
[04:36:54] [PASSED] drm_test_format_min_pitch_two_plane
[04:36:54] [PASSED] drm_test_format_min_pitch_three_plane_8bpp
[04:36:54] [PASSED] drm_test_format_min_pitch_tiled
[04:36:54] =================== [PASSED] drm_format ====================
[04:36:54] ============== drm_framebuffer (10 subtests) ===============
[04:36:54] ========== drm_test_framebuffer_check_src_coords  ==========
[04:36:54] [PASSED] Success: source fits into fb
[04:36:54] [PASSED] Fail: overflowing fb with x-axis coordinate
[04:36:54] [PASSED] Fail: overflowing fb with y-axis coordinate
[04:36:54] [PASSED] Fail: overflowing fb with source width
[04:36:54] [PASSED] Fail: overflowing fb with source height
[04:36:54] ====== [PASSED] drm_test_framebuffer_check_src_coords ======
[04:36:54] [PASSED] drm_test_framebuffer_cleanup
[04:36:54] =============== drm_test_framebuffer_create  ===============
[04:36:54] [PASSED] ABGR8888 normal sizes
[04:36:54] [PASSED] ABGR8888 max sizes
[04:36:54] [PASSED] ABGR8888 pitch greater than min required
[04:36:54] [PASSED] ABGR8888 pitch less than min required
[04:36:54] [PASSED] ABGR8888 Invalid width
[04:36:54] [PASSED] ABGR8888 Invalid buffer handle
[04:36:54] [PASSED] No pixel format
[04:36:54] [PASSED] ABGR8888 Width 0
[04:36:54] [PASSED] ABGR8888 Height 0
[04:36:54] [PASSED] ABGR8888 Out of bound height * pitch combination
[04:36:54] [PASSED] ABGR8888 Large buffer offset
[04:36:54] [PASSED] ABGR8888 Buffer offset for inexistent plane
[04:36:54] [PASSED] ABGR8888 Invalid flag
[04:36:54] [PASSED] ABGR8888 Set DRM_MODE_FB_MODIFIERS without modifiers
[04:36:54] [PASSED] ABGR8888 Valid buffer modifier
[04:36:54] [PASSED] ABGR8888 Invalid buffer modifier(DRM_FORMAT_MOD_SAMSUNG_64_32_TILE)
[04:36:54] [PASSED] ABGR8888 Extra pitches without DRM_MODE_FB_MODIFIERS
[04:36:54] [PASSED] ABGR8888 Extra pitches with DRM_MODE_FB_MODIFIERS
[04:36:54] [PASSED] NV12 Normal sizes
[04:36:54] [PASSED] NV12 Max sizes
[04:36:54] [PASSED] NV12 Invalid pitch
[04:36:54] [PASSED] NV12 Invalid modifier/missing DRM_MODE_FB_MODIFIERS flag
[04:36:54] [PASSED] NV12 different  modifier per-plane
[04:36:54] [PASSED] NV12 with DRM_FORMAT_MOD_SAMSUNG_64_32_TILE
[04:36:54] [PASSED] NV12 Valid modifiers without DRM_MODE_FB_MODIFIERS
[04:36:54] [PASSED] NV12 Modifier for inexistent plane
[04:36:54] [PASSED] NV12 Handle for inexistent plane
[04:36:54] [PASSED] NV12 Handle for inexistent plane without DRM_MODE_FB_MODIFIERS
[04:36:54] [PASSED] YVU420 DRM_MODE_FB_MODIFIERS set without modifier
[04:36:54] [PASSED] YVU420 Normal sizes
[04:36:54] [PASSED] YVU420 Max sizes
[04:36:54] [PASSED] YVU420 Invalid pitch
[04:36:54] [PASSED] YVU420 Different pitches
[04:36:54] [PASSED] YVU420 Different buffer offsets/pitches
[04:36:54] [PASSED] YVU420 Modifier set just for plane 0, without DRM_MODE_FB_MODIFIERS
[04:36:54] [PASSED] YVU420 Modifier set just for planes 0, 1, without DRM_MODE_FB_MODIFIERS
[04:36:54] [PASSED] YVU420 Modifier set just for plane 0, 1, with DRM_MODE_FB_MODIFIERS
[04:36:54] [PASSED] YVU420 Valid modifier
[04:36:54] [PASSED] YVU420 Different modifiers per plane
[04:36:54] [PASSED] YVU420 Modifier for inexistent plane
[04:36:54] [PASSED] YUV420_10BIT Invalid modifier(DRM_FORMAT_MOD_LINEAR)
[04:36:54] [PASSED] X0L2 Normal sizes
[04:36:54] [PASSED] X0L2 Max sizes
[04:36:54] [PASSED] X0L2 Invalid pitch
[04:36:54] [PASSED] X0L2 Pitch greater than minimum required
[04:36:54] [PASSED] X0L2 Handle for inexistent plane
[04:36:54] [PASSED] X0L2 Offset for inexistent plane, without DRM_MODE_FB_MODIFIERS set
[04:36:54] [PASSED] X0L2 Modifier without DRM_MODE_FB_MODIFIERS set
[04:36:54] [PASSED] X0L2 Valid modifier
[04:36:54] [PASSED] X0L2 Modifier for inexistent plane
[04:36:54] =========== [PASSED] drm_test_framebuffer_create ===========
[04:36:54] [PASSED] drm_test_framebuffer_free
[04:36:54] [PASSED] drm_test_framebuffer_init
[04:36:54] [PASSED] drm_test_framebuffer_init_bad_format
[04:36:54] [PASSED] drm_test_framebuffer_init_dev_mismatch
[04:36:54] [PASSED] drm_test_framebuffer_lookup
[04:36:54] [PASSED] drm_test_framebuffer_lookup_inexistent
[04:36:54] [PASSED] drm_test_framebuffer_modifiers_not_supported
[04:36:54] ================= [PASSED] drm_framebuffer =================
[04:36:54] ================ drm_gem_shmem (8 subtests) ================
[04:36:54] [PASSED] drm_gem_shmem_test_obj_create
[04:36:54] [PASSED] drm_gem_shmem_test_obj_create_private
[04:36:54] [PASSED] drm_gem_shmem_test_pin_pages
[04:36:54] [PASSED] drm_gem_shmem_test_vmap
[04:36:54] [PASSED] drm_gem_shmem_test_get_sg_table
[04:36:54] [PASSED] drm_gem_shmem_test_get_pages_sgt
[04:36:54] [PASSED] drm_gem_shmem_test_madvise
[04:36:54] [PASSED] drm_gem_shmem_test_purge
[04:36:54] ================== [PASSED] drm_gem_shmem ==================
[04:36:54] === drm_atomic_helper_connector_hdmi_check (29 subtests) ===
[04:36:54] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode
[04:36:54] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode_vic_1
[04:36:54] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode
[04:36:54] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode_vic_1
[04:36:54] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode
[04:36:54] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode_vic_1
[04:36:54] ====== drm_test_check_broadcast_rgb_cea_mode_yuv420  =======
[04:36:54] [PASSED] Automatic
[04:36:54] [PASSED] Full
[04:36:54] [PASSED] Limited 16:235
[04:36:54] == [PASSED] drm_test_check_broadcast_rgb_cea_mode_yuv420 ===
[04:36:54] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_changed
[04:36:54] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_not_changed
[04:36:54] [PASSED] drm_test_check_disable_connector
[04:36:54] [PASSED] drm_test_check_hdmi_funcs_reject_rate
[04:36:54] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_rgb
[04:36:54] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_yuv420
[04:36:54] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv422
[04:36:54] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv420
[04:36:54] [PASSED] drm_test_check_driver_unsupported_fallback_yuv420
[04:36:54] [PASSED] drm_test_check_output_bpc_crtc_mode_changed
[04:36:54] [PASSED] drm_test_check_output_bpc_crtc_mode_not_changed
[04:36:54] [PASSED] drm_test_check_output_bpc_dvi
[04:36:54] [PASSED] drm_test_check_output_bpc_format_vic_1
[04:36:54] [PASSED] drm_test_check_output_bpc_format_display_8bpc_only
[04:36:54] [PASSED] drm_test_check_output_bpc_format_display_rgb_only
[04:36:54] [PASSED] drm_test_check_output_bpc_format_driver_8bpc_only
[04:36:54] [PASSED] drm_test_check_output_bpc_format_driver_rgb_only
[04:36:54] [PASSED] drm_test_check_tmds_char_rate_rgb_8bpc
[04:36:54] [PASSED] drm_test_check_tmds_char_rate_rgb_10bpc
[04:36:54] [PASSED] drm_test_check_tmds_char_rate_rgb_12bpc
[04:36:54] ============ drm_test_check_hdmi_color_format  =============
[04:36:54] [PASSED] AUTO -> RGB
[04:36:54] [PASSED] YCBCR422 -> YUV422
[04:36:54] [PASSED] YCBCR420 -> YUV420
[04:36:54] [PASSED] YCBCR444 -> YUV444
[04:36:54] [PASSED] RGB -> RGB
[04:36:54] ======== [PASSED] drm_test_check_hdmi_color_format =========
[04:36:54] ======== drm_test_check_hdmi_color_format_420_only  ========
[04:36:54] [PASSED] RGB should fail
[04:36:54] [PASSED] YUV444 should fail
[04:36:54] [PASSED] YUV422 should fail
[04:36:54] [PASSED] YUV420 should work
[04:36:54] ==== [PASSED] drm_test_check_hdmi_color_format_420_only ====
[04:36:54] ===== [PASSED] drm_atomic_helper_connector_hdmi_check ======
[04:36:54] === drm_atomic_helper_connector_hdmi_reset (6 subtests) ====
[04:36:54] [PASSED] drm_test_check_broadcast_rgb_value
[04:36:54] [PASSED] drm_test_check_bpc_8_value
[04:36:54] [PASSED] drm_test_check_bpc_10_value
[04:36:54] [PASSED] drm_test_check_bpc_12_value
[04:36:54] [PASSED] drm_test_check_format_value
[04:36:54] [PASSED] drm_test_check_tmds_char_value
[04:36:54] ===== [PASSED] drm_atomic_helper_connector_hdmi_reset ======
[04:36:54] = drm_atomic_helper_connector_hdmi_mode_valid (7 subtests) =
[04:36:54] [PASSED] drm_test_check_mode_valid
[04:36:54] [PASSED] drm_test_check_mode_valid_reject
[04:36:54] [PASSED] drm_test_check_mode_valid_reject_rate
[04:36:54] [PASSED] drm_test_check_mode_valid_reject_max_clock
[04:36:54] [PASSED] drm_test_check_mode_valid_yuv420_only_max_clock
[04:36:54] [PASSED] drm_test_check_mode_valid_reject_yuv420_only_connector
[04:36:54] [PASSED] drm_test_check_mode_valid_accept_yuv420_also_connector_rgb
[04:36:54] === [PASSED] drm_atomic_helper_connector_hdmi_mode_valid ===
[04:36:54] = drm_atomic_helper_connector_hdmi_infoframes (5 subtests) =
[04:36:54] [PASSED] drm_test_check_infoframes
[04:36:54] [PASSED] drm_test_check_reject_avi_infoframe
[04:36:54] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_8
[04:36:54] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_10
[04:36:54] [PASSED] drm_test_check_reject_audio_infoframe
[04:36:54] === [PASSED] drm_atomic_helper_connector_hdmi_infoframes ===
[04:36:54] ================= drm_managed (2 subtests) =================
[04:36:54] [PASSED] drm_test_managed_release_action
[04:36:54] [PASSED] drm_test_managed_run_action
[04:36:54] =================== [PASSED] drm_managed ===================
[04:36:54] =================== drm_mm (6 subtests) ====================
[04:36:54] [PASSED] drm_test_mm_init
[04:36:54] [PASSED] drm_test_mm_debug
[04:36:54] [PASSED] drm_test_mm_align32
[04:36:54] [PASSED] drm_test_mm_align64
[04:36:54] [PASSED] drm_test_mm_lowest
[04:36:54] [PASSED] drm_test_mm_highest
[04:36:54] ===================== [PASSED] drm_mm ======================
[04:36:54] ============= drm_modes_analog_tv (5 subtests) =============
[04:36:54] [PASSED] drm_test_modes_analog_tv_mono_576i
[04:36:54] [PASSED] drm_test_modes_analog_tv_ntsc_480i
[04:36:54] [PASSED] drm_test_modes_analog_tv_ntsc_480i_inlined
[04:36:54] [PASSED] drm_test_modes_analog_tv_pal_576i
[04:36:54] [PASSED] drm_test_modes_analog_tv_pal_576i_inlined
[04:36:54] =============== [PASSED] drm_modes_analog_tv ===============
[04:36:54] ============== drm_plane_helper (2 subtests) ===============
[04:36:54] =============== drm_test_check_plane_state  ================
[04:36:54] [PASSED] clipping_simple
[04:36:54] [PASSED] clipping_rotate_reflect
[04:36:54] [PASSED] positioning_simple
[04:36:54] [PASSED] upscaling
[04:36:54] [PASSED] downscaling
[04:36:54] [PASSED] rounding1
[04:36:54] [PASSED] rounding2
[04:36:54] [PASSED] rounding3
[04:36:54] [PASSED] rounding4
[04:36:54] =========== [PASSED] drm_test_check_plane_state ============
[04:36:54] =========== drm_test_check_invalid_plane_state  ============
[04:36:54] [PASSED] positioning_invalid
[04:36:54] [PASSED] upscaling_invalid
[04:36:54] [PASSED] downscaling_invalid
[04:36:54] ======= [PASSED] drm_test_check_invalid_plane_state ========
[04:36:54] ================ [PASSED] drm_plane_helper =================
[04:36:54] ====== drm_connector_helper_tv_get_modes (1 subtest) =======
[04:36:54] ====== drm_test_connector_helper_tv_get_modes_check  =======
[04:36:54] [PASSED] None
[04:36:54] [PASSED] PAL
[04:36:54] [PASSED] NTSC
[04:36:54] [PASSED] Both, NTSC Default
[04:36:54] [PASSED] Both, PAL Default
[04:36:54] [PASSED] Both, NTSC Default, with PAL on command-line
[04:36:54] [PASSED] Both, PAL Default, with NTSC on command-line
[04:36:54] == [PASSED] drm_test_connector_helper_tv_get_modes_check ===
[04:36:54] ======== [PASSED] drm_connector_helper_tv_get_modes ========
[04:36:54] ================== drm_rect (9 subtests) ===================
[04:36:54] [PASSED] drm_test_rect_clip_scaled_div_by_zero
[04:36:54] [PASSED] drm_test_rect_clip_scaled_not_clipped
[04:36:54] [PASSED] drm_test_rect_clip_scaled_clipped
[04:36:54] [PASSED] drm_test_rect_clip_scaled_signed_vs_unsigned
[04:36:54] ================= drm_test_rect_intersect  =================
[04:36:54] [PASSED] top-left x bottom-right: 2x2+1+1 x 2x2+0+0
[04:36:54] [PASSED] top-right x bottom-left: 2x2+0+0 x 2x2+1-1
[04:36:54] [PASSED] bottom-left x top-right: 2x2+1-1 x 2x2+0+0
[04:36:54] [PASSED] bottom-right x top-left: 2x2+0+0 x 2x2+1+1
[04:36:54] [PASSED] right x left: 2x1+0+0 x 3x1+1+0
[04:36:54] [PASSED] left x right: 3x1+1+0 x 2x1+0+0
[04:36:54] [PASSED] up x bottom: 1x2+0+0 x 1x3+0-1
[04:36:54] [PASSED] bottom x up: 1x3+0-1 x 1x2+0+0
[04:36:54] [PASSED] touching corner: 1x1+0+0 x 2x2+1+1
[04:36:54] [PASSED] touching side: 1x1+0+0 x 1x1+1+0
[04:36:54] [PASSED] equal rects: 2x2+0+0 x 2x2+0+0
[04:36:54] [PASSED] inside another: 2x2+0+0 x 1x1+1+1
[04:36:54] [PASSED] far away: 1x1+0+0 x 1x1+3+6
[04:36:54] [PASSED] points intersecting: 0x0+5+10 x 0x0+5+10
[04:36:54] [PASSED] points not intersecting: 0x0+0+0 x 0x0+5+10
[04:36:54] ============= [PASSED] drm_test_rect_intersect =============
[04:36:54] ================ drm_test_rect_calc_hscale  ================
[04:36:54] [PASSED] normal use
[04:36:54] [PASSED] out of max range
[04:36:54] [PASSED] out of min range
[04:36:54] [PASSED] zero dst
[04:36:54] [PASSED] negative src
[04:36:54] [PASSED] negative dst
[04:36:54] ============ [PASSED] drm_test_rect_calc_hscale ============
[04:36:54] ================ drm_test_rect_calc_vscale  ================
[04:36:54] [PASSED] normal use
[04:36:54] [PASSED] out of max range
[04:36:54] [PASSED] out of min range
[04:36:54] [PASSED] zero dst
[04:36:54] [PASSED] negative src
[04:36:54] [PASSED] negative dst
[04:36:54] ============ [PASSED] drm_test_rect_calc_vscale ============
[04:36:54] ================== drm_test_rect_rotate  ===================
[04:36:54] [PASSED] reflect-x
[04:36:54] [PASSED] reflect-y
[04:36:54] [PASSED] rotate-0
[04:36:54] [PASSED] rotate-90
[04:36:54] [PASSED] rotate-180
[04:36:54] [PASSED] rotate-270
[04:36:54] ============== [PASSED] drm_test_rect_rotate ===============
[04:36:54] ================ drm_test_rect_rotate_inv  =================
[04:36:54] [PASSED] reflect-x
[04:36:54] [PASSED] reflect-y
[04:36:54] [PASSED] rotate-0
[04:36:54] [PASSED] rotate-90
[04:36:54] [PASSED] rotate-180
[04:36:54] [PASSED] rotate-270
[04:36:54] ============ [PASSED] drm_test_rect_rotate_inv =============
[04:36:54] ==================== [PASSED] drm_rect =====================
[04:36:54] ============ drm_sysfb_modeset_test (1 subtest) ============
[04:36:54] ============ drm_test_sysfb_build_fourcc_list  =============
[04:36:54] [PASSED] no native formats
[04:36:54] [PASSED] XRGB8888 as native format
[04:36:54] [PASSED] remove duplicates
[04:36:54] [PASSED] convert alpha formats
[04:36:54] [PASSED] random formats
[04:36:54] ======== [PASSED] drm_test_sysfb_build_fourcc_list =========
[04:36:54] ============= [PASSED] drm_sysfb_modeset_test ==============
[04:36:54] ================== drm_fixp (2 subtests) ===================
[04:36:54] [PASSED] drm_test_int2fixp
[04:36:54] [PASSED] drm_test_sm2fixp
[04:36:54] ==================== [PASSED] drm_fixp =====================
[04:36:54] ============================================================
[04:36:54] Testing complete. Ran 639 tests: passed: 639
[04:36:54] Elapsed time: 26.251s total, 1.785s configuring, 24.299s building, 0.147s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/ttm/tests/.kunitconfig [04:36:54] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:

$ make ARCH=um O=.kunit olddefconfig
[04:36:56] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[04:37:05] Starting KUnit Kernel (1/1)...
[04:37:05] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[04:37:05] ================= ttm_device (5 subtests) ==================
[04:37:05] [PASSED] ttm_device_init_basic
[04:37:05] [PASSED] ttm_device_init_multiple
[04:37:05] [PASSED] ttm_device_fini_basic
[04:37:05] [PASSED] ttm_device_init_no_vma_man
[04:37:05] ================== ttm_device_init_pools  ==================
[04:37:05] [PASSED] No DMA allocations, no DMA32 required
[04:37:05] [PASSED] DMA allocations, DMA32 required
[04:37:05] [PASSED] No DMA allocations, DMA32 required
[04:37:05] [PASSED] DMA allocations, no DMA32 required
[04:37:05] ============== [PASSED] ttm_device_init_pools ==============
[04:37:05] =================== [PASSED] ttm_device ====================
[04:37:05] ================== ttm_pool (8 subtests) ===================
[04:37:05] ================== ttm_pool_alloc_basic  ===================
[04:37:05] [PASSED] One page
[04:37:05] [PASSED] More than one page
[04:37:05] [PASSED] Above the allocation limit
[04:37:05] [PASSED] One page, with coherent DMA mappings enabled
[04:37:05] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[04:37:05] ============== [PASSED] ttm_pool_alloc_basic ===============
[04:37:05] ============== ttm_pool_alloc_basic_dma_addr  ==============
[04:37:05] [PASSED] One page
[04:37:05] [PASSED] More than one page
[04:37:05] [PASSED] Above the allocation limit
[04:37:05] [PASSED] One page, with coherent DMA mappings enabled
[04:37:05] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[04:37:05] ========== [PASSED] ttm_pool_alloc_basic_dma_addr ==========
[04:37:05] [PASSED] ttm_pool_alloc_order_caching_match
[04:37:05] [PASSED] ttm_pool_alloc_caching_mismatch
[04:37:05] [PASSED] ttm_pool_alloc_order_mismatch
[04:37:05] [PASSED] ttm_pool_free_dma_alloc
[04:37:05] [PASSED] ttm_pool_free_no_dma_alloc
[04:37:05] [PASSED] ttm_pool_fini_basic
[04:37:05] ==================== [PASSED] ttm_pool =====================
[04:37:05] ================ ttm_resource (8 subtests) =================
[04:37:05] ================= ttm_resource_init_basic  =================
[04:37:05] [PASSED] Init resource in TTM_PL_SYSTEM
[04:37:05] [PASSED] Init resource in TTM_PL_VRAM
[04:37:05] [PASSED] Init resource in a private placement
[04:37:05] [PASSED] Init resource in TTM_PL_SYSTEM, set placement flags
[04:37:05] ============= [PASSED] ttm_resource_init_basic =============
[04:37:05] [PASSED] ttm_resource_init_pinned
[04:37:05] [PASSED] ttm_resource_fini_basic
[04:37:05] [PASSED] ttm_resource_manager_init_basic
[04:37:05] [PASSED] ttm_resource_manager_usage_basic
[04:37:05] [PASSED] ttm_resource_manager_set_used_basic
[04:37:05] [PASSED] ttm_sys_man_alloc_basic
[04:37:05] [PASSED] ttm_sys_man_free_basic
[04:37:05] ================== [PASSED] ttm_resource ===================
[04:37:05] =================== ttm_tt (15 subtests) ===================
[04:37:05] ==================== ttm_tt_init_basic  ====================
[04:37:05] [PASSED] Page-aligned size
[04:37:05] [PASSED] Extra pages requested
[04:37:05] ================ [PASSED] ttm_tt_init_basic ================
[04:37:05] [PASSED] ttm_tt_init_misaligned
[04:37:05] [PASSED] ttm_tt_fini_basic
[04:37:05] [PASSED] ttm_tt_fini_sg
[04:37:05] [PASSED] ttm_tt_fini_shmem
[04:37:05] [PASSED] ttm_tt_create_basic
[04:37:05] [PASSED] ttm_tt_create_invalid_bo_type
[04:37:05] [PASSED] ttm_tt_create_ttm_exists
[04:37:05] [PASSED] ttm_tt_create_failed
[04:37:05] [PASSED] ttm_tt_destroy_basic
[04:37:05] [PASSED] ttm_tt_populate_null_ttm
[04:37:05] [PASSED] ttm_tt_populate_populated_ttm
[04:37:05] [PASSED] ttm_tt_unpopulate_basic
[04:37:05] [PASSED] ttm_tt_unpopulate_empty_ttm
[04:37:05] [PASSED] ttm_tt_swapin_basic
[04:37:05] ===================== [PASSED] ttm_tt ======================
[04:37:05] =================== ttm_bo (14 subtests) ===================
[04:37:05] =========== ttm_bo_reserve_optimistic_no_ticket  ===========
[04:37:05] [PASSED] Cannot be interrupted and sleeps
[04:37:05] [PASSED] Cannot be interrupted, locks straight away
[04:37:05] [PASSED] Can be interrupted, sleeps
[04:37:05] ======= [PASSED] ttm_bo_reserve_optimistic_no_ticket =======
[04:37:05] [PASSED] ttm_bo_reserve_locked_no_sleep
[04:37:05] [PASSED] ttm_bo_reserve_no_wait_ticket
[04:37:05] [PASSED] ttm_bo_reserve_double_resv
[04:37:05] [PASSED] ttm_bo_reserve_interrupted
[04:37:05] [PASSED] ttm_bo_reserve_deadlock
[04:37:05] [PASSED] ttm_bo_unreserve_basic
[04:37:05] [PASSED] ttm_bo_unreserve_pinned
[04:37:05] [PASSED] ttm_bo_unreserve_bulk
[04:37:05] [PASSED] ttm_bo_fini_basic
[04:37:05] [PASSED] ttm_bo_fini_shared_resv
[04:37:05] [PASSED] ttm_bo_pin_basic
[04:37:05] [PASSED] ttm_bo_pin_unpin_resource
[04:37:05] [PASSED] ttm_bo_multiple_pin_one_unpin
[04:37:05] ===================== [PASSED] ttm_bo ======================
[04:37:05] ============== ttm_bo_validate (22 subtests) ===============
[04:37:05] ============== ttm_bo_init_reserved_sys_man  ===============
[04:37:05] [PASSED] Buffer object for userspace
[04:37:05] [PASSED] Kernel buffer object
[04:37:05] [PASSED] Shared buffer object
[04:37:05] ========== [PASSED] ttm_bo_init_reserved_sys_man ===========
[04:37:05] ============== ttm_bo_init_reserved_mock_man  ==============
[04:37:05] [PASSED] Buffer object for userspace
[04:37:05] [PASSED] Kernel buffer object
[04:37:05] [PASSED] Shared buffer object
[04:37:05] ========== [PASSED] ttm_bo_init_reserved_mock_man ==========
[04:37:05] [PASSED] ttm_bo_init_reserved_resv
[04:37:05] ================== ttm_bo_validate_basic  ==================
[04:37:05] [PASSED] Buffer object for userspace
[04:37:05] [PASSED] Kernel buffer object
[04:37:05] [PASSED] Shared buffer object
[04:37:05] ============== [PASSED] ttm_bo_validate_basic ==============
[04:37:05] [PASSED] ttm_bo_validate_invalid_placement
[04:37:05] ============= ttm_bo_validate_same_placement  ==============
[04:37:05] [PASSED] System manager
[04:37:05] [PASSED] VRAM manager
[04:37:05] ========= [PASSED] ttm_bo_validate_same_placement ==========
[04:37:05] [PASSED] ttm_bo_validate_failed_alloc
[04:37:05] [PASSED] ttm_bo_validate_pinned
[04:37:05] [PASSED] ttm_bo_validate_busy_placement
[04:37:05] ================ ttm_bo_validate_multihop  =================
[04:37:05] [PASSED] Buffer object for userspace
[04:37:05] [PASSED] Kernel buffer object
[04:37:05] [PASSED] Shared buffer object
[04:37:05] ============ [PASSED] ttm_bo_validate_multihop =============
[04:37:05] ========== ttm_bo_validate_no_placement_signaled  ==========
[04:37:05] [PASSED] Buffer object in system domain, no page vector
[04:37:05] [PASSED] Buffer object in system domain with an existing page vector
[04:37:05] ====== [PASSED] ttm_bo_validate_no_placement_signaled ======
[04:37:05] ======== ttm_bo_validate_no_placement_not_signaled  ========
[04:37:05] [PASSED] Buffer object for userspace
[04:37:05] [PASSED] Kernel buffer object
[04:37:05] [PASSED] Shared buffer object
[04:37:05] ==== [PASSED] ttm_bo_validate_no_placement_not_signaled ====
[04:37:05] [PASSED] ttm_bo_validate_move_fence_signaled
[04:37:06] ========= ttm_bo_validate_move_fence_not_signaled  =========
[04:37:06] [PASSED] Waits for GPU
[04:37:06] [PASSED] Tries to lock straight away
[04:37:06] ===== [PASSED] ttm_bo_validate_move_fence_not_signaled =====
[04:37:06] [PASSED] ttm_bo_validate_swapout
[04:37:06] [PASSED] ttm_bo_validate_happy_evict
[04:37:06] [PASSED] ttm_bo_validate_all_pinned_evict
[04:37:06] [PASSED] ttm_bo_validate_allowed_only_evict
[04:37:06] [PASSED] ttm_bo_validate_deleted_evict
[04:37:06] [PASSED] ttm_bo_validate_busy_domain_evict
[04:37:06] [PASSED] ttm_bo_validate_evict_gutting
[04:37:06] [PASSED] ttm_bo_validate_recrusive_evict
[04:37:06] ================= [PASSED] ttm_bo_validate =================
[04:37:06] ============================================================
[04:37:06] Testing complete. Ran 102 tests: passed: 102
[04:37:06] Elapsed time: 11.492s total, 1.769s configuring, 9.457s building, 0.226s running

+ cleanup
++ stat -c %u:%g /kernel
+ chown -R 1003:1003 /kernel

#12 lore raw

✓ Xe.CI.BAT: success for mm, drm/xe: Avoid reclaim/eviction loops under fragmentation

In reply to Matthew Brost
== Series Details ==

== Series Details ==

Series: mm, drm/xe: Avoid reclaim/eviction loops under fragmentation
URL : https://patchwork.freedesktop.org/series/168651/
State : success

== Summary ==

CI Bug Log - changes from xe-5269-29ea43790111df065ed84e6cb076c64322c306f1_BAT -> xe-pw-168651v1_BAT
====================================================

Summary
-------

**SUCCESS**

No regressions found.

Participating hosts (13 -> 13)
------------------------------

No changes in participating hosts

Known issues
------------

Here are the changes found in xe-pw-168651v1_BAT that come from known issues:

### IGT changes ###

#### Possible fixes ####

* igt@xe_waitfence@engine:
- bat-bmg-2: [FAIL][1] ([Intel XE#6519]) -> [PASS][2]
[1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/bat-bmg-2/igt@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/bat-bmg-2/igt@[email protected]

[Intel XE#6519]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6519

Build changes
-------------

* IGT: IGT_8966 -> IGT_8967
* Linux: xe-5269-29ea43790111df065ed84e6cb076c64322c306f1 -> xe-pw-168651v1

IGT_8966: 9b33225c761bfe8c8c266bc56558d75c700029fb @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
IGT_8967: 46e60a541c8ce6e4e0046bb68fc577c4b502e5f2 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
xe-5269-29ea43790111df065ed84e6cb076c64322c306f1: 29ea43790111df065ed84e6cb076c64322c306f1
xe-pw-168651v1: 168651v1

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/index.html

#13 lore raw

✓ Xe.CI.FULL: success for mm, drm/xe: Avoid reclaim/eviction loops under fragmentation

In reply to Matthew Brost
== Series Details ==

== Series Details ==

Series: mm, drm/xe: Avoid reclaim/eviction loops under fragmentation
URL : https://patchwork.freedesktop.org/series/168651/
State : success

== Summary ==

CI Bug Log - changes from xe-5269-29ea43790111df065ed84e6cb076c64322c306f1_FULL -> xe-pw-168651v1_FULL
====================================================

Summary
-------

**SUCCESS**

No regressions found.

Participating hosts (2 -> 2)
------------------------------

No changes in participating hosts

New tests
---------

New tests have been introduced between xe-5269-29ea43790111df065ed84e6cb076c64322c306f1_FULL and xe-pw-168651v1_FULL:

### New IGT tests (1) ###

* igt@kms_addfb_basic:
- Statuses :
- Exec time: [None] s

Known issues
------------

Here are the changes found in xe-pw-168651v1_FULL that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@kms_addfb_basic@addfb25-y-tiled-small-legacy:
- shard-bmg: NOTRUN -> [SKIP][1] ([Intel XE#2233])
[1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-6/igt@[email protected]

* igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels:
- shard-bmg: NOTRUN -> [SKIP][2] ([Intel XE#2370])
[2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-10/igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels.html

* igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-180-async-flip:
- shard-bmg: NOTRUN -> [SKIP][3] ([Intel XE#1124]) +2 other tests skip
[3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-5/igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-180-async-flip.html

* igt@kms_bw@linear-tiling-2-displays-target-3840x2160p:
- shard-bmg: NOTRUN -> [SKIP][4] ([Intel XE#367]) +1 other test skip
[4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-9/igt@[email protected]

* igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs@pipe-c-dp-2:
- shard-bmg: NOTRUN -> [INCOMPLETE][5] ([Intel XE#7084] / [Intel XE#8150]) +1 other test incomplete
[5]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-6/igt@kms_ccs@[email protected]

* igt@kms_ccs@crc-primary-suspend-4-tiled-mtl-rc-ccs-cc:
- shard-bmg: NOTRUN -> [SKIP][6] ([Intel XE#3432])
[6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-4/igt@[email protected]

* igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs-cc:
- shard-bmg: NOTRUN -> [SKIP][7] ([Intel XE#2887]) +3 other tests skip
[7]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-7/igt@[email protected]

* igt@kms_chamelium_edid@dp-edid-stress-resolution-4k:
- shard-bmg: NOTRUN -> [SKIP][8] ([Intel XE#2252]) +1 other test skip
[8]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-1/igt@[email protected]

* igt@kms_content_protection@lic-type-1:
- shard-bmg: NOTRUN -> [SKIP][9] ([Intel XE#7642])
[9]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-10/igt@[email protected]

* igt@kms_cursor_crc@cursor-offscreen-max-size:
- shard-bmg: NOTRUN -> [SKIP][10] ([Intel XE#2320])
[10]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-4/igt@[email protected]

* igt@kms_cursor_crc@cursor-random-512x512:
- shard-bmg: NOTRUN -> [SKIP][11] ([Intel XE#2321] / [Intel XE#7355])
[11]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-2/igt@[email protected]

* igt@kms_dsc@dsc-with-output-formats-with-bpc-ultrajoiner:
- shard-bmg: NOTRUN -> [SKIP][12] ([Intel XE#8265]) +1 other test skip
[12]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-5/igt@[email protected]

* igt@kms_fbcon_fbt@psr-suspend:
- shard-bmg: NOTRUN -> [SKIP][13] ([Intel XE#6126] / [Intel XE#776])
[13]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-7/igt@[email protected]

* igt@kms_flip@flip-vs-expired-vblank@a-edp1:
- shard-lnl: [PASS][14] -> [FAIL][15] ([Intel XE#301])
[14]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-lnl-3/igt@kms_flip@[email protected]
[15]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-lnl-4/igt@kms_flip@[email protected]

* igt@kms_flip@wf_vblank-ts-check-interruptible@a-edp1:
- shard-lnl: [PASS][16] -> [FAIL][17] ([Intel XE#3098]) +1 other test fail
[16]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-lnl-7/igt@kms_flip@[email protected]
[17]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-lnl-1/igt@kms_flip@[email protected]

* igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-downscaling:
- shard-bmg: NOTRUN -> [SKIP][18] ([Intel XE#7178] / [Intel XE#7351])
[18]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-1/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-downscaling.html

* igt@kms_frontbuffer_tracking@drrs-rgb101010-draw-render:
- shard-bmg: NOTRUN -> [SKIP][19] ([Intel XE#2311]) +21 other tests skip
[19]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-5/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-draw-render:
- shard-bmg: NOTRUN -> [SKIP][20] ([Intel XE#4141]) +4 other tests skip
[20]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-7/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-cur-indfb-draw-render.html

* igt@kms_frontbuffer_tracking@fbc-tiling-y:
- shard-bmg: NOTRUN -> [SKIP][21] ([Intel XE#2352] / [Intel XE#7399])
[21]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-8/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcdrrs-argb161616f-draw-blt:
- shard-bmg: NOTRUN -> [SKIP][22] ([Intel XE#7061] / [Intel XE#7356])
[22]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-6/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbchdr-abgr161616f-draw-blt:
- shard-bmg: NOTRUN -> [SKIP][23] ([Intel XE#7061]) +1 other test skip
[23]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-4/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcpsr-indfb-scaledprimary:
- shard-bmg: NOTRUN -> [SKIP][24] ([Intel XE#2313]) +14 other tests skip
[24]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-4/igt@[email protected]

* igt@kms_hdmi_inject@inject-audio:
- shard-bmg: [PASS][25] -> [SKIP][26] ([Intel XE#7308])
[25]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-bmg-4/igt@[email protected]
[26]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-9/igt@[email protected]

* igt@kms_joiner@basic-max-non-joiner:
- shard-bmg: NOTRUN -> [SKIP][27] ([Intel XE#4298] / [Intel XE#5873])
[27]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-1/igt@[email protected]

* igt@kms_plane@pixel-format-y-tiled-gen12-mc-ccs-modifier:
- shard-bmg: NOTRUN -> [SKIP][28] ([Intel XE#7283]) +1 other test skip
[28]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-10/igt@[email protected]

* igt@kms_pm_backlight@fade:
- shard-bmg: NOTRUN -> [SKIP][29] ([Intel XE#7376] / [Intel XE#7760] / [Intel XE#870])
[29]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-9/igt@[email protected]

* igt@kms_pm_rpm@modeset-lpsp-stress:
- shard-bmg: NOTRUN -> [SKIP][30] ([Intel XE#1439] / [Intel XE#3141] / [Intel XE#7383] / [Intel XE#836])
[30]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-5/igt@[email protected]

* igt@kms_psr2_sf@fbc-psr2-overlay-plane-update-sf-dmg-area:
- shard-bmg: NOTRUN -> [SKIP][31] ([Intel XE#1489]) +1 other test skip
[31]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-1/igt@[email protected]

* igt@kms_psr@pr-sprite-plane-onoff:
- shard-bmg: NOTRUN -> [SKIP][32] ([Intel XE#2234] / [Intel XE#2850]) +2 other tests skip
[32]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-7/igt@[email protected]

* igt@kms_rotation_crc@primary-yf-tiled-reflect-x-90:
- shard-bmg: NOTRUN -> [SKIP][33] ([Intel XE#3904] / [Intel XE#7342])
[33]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-2/igt@[email protected]

* igt@kms_sharpness_filter@invalid-filter-with-nearest-neighbor:
- shard-bmg: NOTRUN -> [SKIP][34] ([Intel XE#6503])
[34]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-7/igt@[email protected]

* igt@kms_vrr@seamless-rr-switch-virtual@pipe-a-edp-1:
- shard-lnl: [PASS][35] -> [FAIL][36] ([Intel XE#2142]) +1 other test fail
[35]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-lnl-3/igt@kms_vrr@[email protected]
[36]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-lnl-7/igt@kms_vrr@[email protected]

* igt@xe_eudebug_online@writes-caching-sram-bb-vram-target-vram:
- shard-bmg: NOTRUN -> [SKIP][37] ([Intel XE#7636]) +2 other tests skip
[37]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-2/igt@[email protected]

* igt@xe_exec_basic@multigpu-many-execqueues-many-vm-userptr-invalidate-race:
- shard-bmg: NOTRUN -> [SKIP][38] ([Intel XE#2322] / [Intel XE#7372]) +1 other test skip
[38]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-9/igt@xe_exec_basic@multigpu-many-execqueues-many-vm-userptr-invalidate-race.html

* igt@xe_exec_fault_mode@once-multi-queue-userptr-rebind-imm:
- shard-bmg: NOTRUN -> [SKIP][39] ([Intel XE#7136]) +3 other tests skip
[39]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-8/igt@[email protected]

* igt@xe_exec_multi_queue@two-queues-preempt-mode-fault-priority:
- shard-bmg: NOTRUN -> [SKIP][40] ([Intel XE#6874]) +9 other tests skip
[40]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-4/igt@[email protected]

* igt@xe_exec_reset@cm-multi-queue-cat-error:
- shard-bmg: NOTRUN -> [SKIP][41] ([Intel XE#7866]) +1 other test skip
[41]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-7/igt@[email protected]

* igt@xe_exec_threads@threads-multi-queue-cm-shared-vm-userptr-invalidate:
- shard-bmg: NOTRUN -> [SKIP][42] ([Intel XE#7138]) +1 other test skip
[42]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-6/igt@xe_exec_threads@threads-multi-queue-cm-shared-vm-userptr-invalidate.html

* igt@xe_fault_injection@exec-queue-create-fail-xe_pxp_exec_queue_add:
- shard-bmg: NOTRUN -> [SKIP][43] ([Intel XE#6281] / [Intel XE#7426])
[43]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-6/igt@xe_fault_injection@exec-queue-create-fail-xe_pxp_exec_queue_add.html

* igt@xe_pat@pat-sw-hw-reset-compare:
- shard-bmg: NOTRUN -> [FAIL][44] ([Intel XE#7695])
[44]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-1/igt@[email protected]

* igt@xe_pm@d3cold-multiple-execs:
- shard-bmg: NOTRUN -> [SKIP][45] ([Intel XE#2284] / [Intel XE#7370])
[45]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-10/igt@[email protected]

* igt@xe_pxp@regular-src-to-pxp-dest-rendercopy:
- shard-bmg: NOTRUN -> [SKIP][46] ([Intel XE#4733] / [Intel XE#7417])
[46]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-5/igt@[email protected]

* igt@xe_query@multigpu-query-invalid-extension:
- shard-bmg: NOTRUN -> [SKIP][47] ([Intel XE#944])
[47]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-10/igt@[email protected]

* igt@xe_wedged@wedged-mode-toggle:
- shard-lnl: [PASS][48] -> [ABORT][49] ([Intel XE#8007])
[48]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-lnl-3/igt@[email protected]
[49]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-lnl-7/igt@[email protected]

#### Possible fixes ####

* igt@kms_cursor_legacy@flip-vs-cursor-atomic:
- shard-bmg: [FAIL][50] ([Intel XE#7809]) -> [PASS][51]
[50]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-bmg-4/igt@[email protected]
[51]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-5/igt@[email protected]

* igt@kms_flip@flip-vs-expired-vblank@c-edp1:
- shard-lnl: [FAIL][52] ([Intel XE#301] / [Intel XE#3149]) -> [PASS][53]
[52]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-lnl-3/igt@kms_flip@[email protected]
[53]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-lnl-4/igt@kms_flip@[email protected]

* igt@kms_hdr@static-swap@pipe-a-hdmi-a-3-xrgb2101010:
- shard-bmg: [SKIP][54] ([Intel XE#7915]) -> [PASS][55] +3 other tests pass
[54]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-bmg-2/igt@kms_hdr@[email protected]
[55]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-5/igt@kms_hdr@[email protected]

* igt@kms_psr_stress_test@flip-primary-invalidate-overlay:
- shard-lnl: [SKIP][56] ([Intel XE#8361]) -> [PASS][57]
[56]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-lnl-5/igt@[email protected]
[57]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-lnl-8/igt@[email protected]

* igt@xe_exec_reset@long-spin-many-preempt-threads:
- shard-bmg: [FAIL][58] ([Intel XE#7956]) -> [PASS][59]
[58]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-bmg-10/igt@[email protected]
[59]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-1/igt@[email protected]

#### Warnings ####

* igt@kms_cursor_legacy@cursorb-vs-flipb-atomic-transitions:
- shard-lnl: [SKIP][60] ([Intel XE#309] / [Intel XE#7343]) -> [SKIP][61] ([Intel XE#309] / [Intel XE#7343] / [Intel XE#7935])
[60]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-lnl-2/igt@[email protected]
[61]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-lnl-8/igt@[email protected]

* igt@kms_flip@flip-vs-expired-vblank:
- shard-lnl: [FAIL][62] ([Intel XE#301] / [Intel XE#3149]) -> [FAIL][63] ([Intel XE#301])
[62]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-lnl-3/igt@[email protected]
[63]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-lnl-4/igt@[email protected]

* igt@xe_evict@evict-mixed-many-threads-small:
- shard-bmg: [INCOMPLETE][64] ([Intel XE#6321]) -> [INCOMPLETE][65] ([Intel XE#6321] / [Intel XE#8355]) +1 other test incomplete
[64]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-5269-29ea43790111df065ed84e6cb076c64322c306f1/shard-bmg-9/igt@[email protected]
[65]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/shard-bmg-8/igt@[email protected]

[Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124
[Intel XE#1439]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1439
[Intel XE#1489]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1489
[Intel XE#2142]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2142
[Intel XE#2233]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2233
[Intel XE#2234]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2234
[Intel XE#2252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2252
[Intel XE#2284]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2284
[Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
[Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
[Intel XE#2320]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2320
[Intel XE#2321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2321
[Intel XE#2322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2322
[Intel XE#2352]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2352
[Intel XE#2370]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2370
[Intel XE#2850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2850
[Intel XE#2887]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2887
[Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301
[Intel XE#309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/309
[Intel XE#3098]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3098
[Intel XE#3141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3141
[Intel XE#3149]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3149
[Intel XE#3432]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3432
[Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367
[Intel XE#3904]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3904
[Intel XE#4141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4141
[Intel XE#4298]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4298
[Intel XE#4733]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4733
[Intel XE#5873]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5873
[Intel XE#6126]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6126
[Intel XE#6281]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6281
[Intel XE#6321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6321
[Intel XE#6503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6503
[Intel XE#6874]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6874
[Intel XE#7061]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7061
[Intel XE#7084]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7084
[Intel XE#7136]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7136
[Intel XE#7138]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7138
[Intel XE#7178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7178
[Intel XE#7283]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7283
[Intel XE#7308]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7308
[Intel XE#7342]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7342
[Intel XE#7343]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7343
[Intel XE#7351]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7351
[Intel XE#7355]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7355
[Intel XE#7356]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7356
[Intel XE#7370]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7370
[Intel XE#7372]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7372
[Intel XE#7376]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7376
[Intel XE#7383]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7383
[Intel XE#7399]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7399
[Intel XE#7417]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7417
[Intel XE#7426]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7426
[Intel XE#7636]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7636
[Intel XE#7642]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7642
[Intel XE#7695]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7695
[Intel XE#776]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/776
[Intel XE#7760]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7760
[Intel XE#7809]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7809
[Intel XE#7866]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7866
[Intel XE#7915]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7915
[Intel XE#7935]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7935
[Intel XE#7956]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7956
[Intel XE#8007]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8007
[Intel XE#8150]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8150
[Intel XE#8265]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8265
[Intel XE#8355]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8355
[Intel XE#836]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/836
[Intel XE#8361]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/8361
[Intel XE#870]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/870
[Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944

Build changes
-------------

* IGT: IGT_8966 -> IGT_8967
* Linux: xe-5269-29ea43790111df065ed84e6cb076c64322c306f1 -> xe-pw-168651v1

IGT_8966: 9b33225c761bfe8c8c266bc56558d75c700029fb @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
IGT_8967: 46e60a541c8ce6e4e0046bb68fc577c4b502e5f2 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
xe-5269-29ea43790111df065ed84e6cb076c64322c306f1: 29ea43790111df065ed84e6cb076c64322c306f1
xe-pw-168651v1: 168651v1

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-168651v1/index.html