Re: [PATCH v4 4/4] drm/xe: Update non-purgeable shrinker batch size based on average BO size

[Matthew Brost <matthew.brost@intel.com>]

On Fri, Oct 16, 2026 at 03:35:23PM +0200, Thomas Hellström wrote:
> Update our preferred vmscan batch size for the non-purgeable shrinker
> on count passes that allow backup (__GFP_FS), to avoid invoking
> scan_objects() for requests too small to free even a single
> average-sized GEM object. Our rough estimate for an effective batch
> is twice the average number of pages per populated ttm_tt across
> the full shrinkable and purgeable population. The factor of two
> provides headroom so that most scan invocations can free at least one
> GEM object despite variability in object sizes.
> 
> The batch value is updated as an exponential moving average,
> (old_batch + avg) / 2, to smooth out sudden changes in the object
> population. It is floored at 128 pages, the kernel default
> SHRINK_BATCH, to ensure the shrinker remains responsive when there
> are very few objects.
> 
> The populated_tts counter introduced in an earlier commit provides the
> object count needed for the average. We inherit the same justification
> as the analogous mechanism in i915: shrinking a GEM object has
> non-trivial per-object overhead, so firing the shrinker for requests
> smaller than a single object is wasteful.
> 
> This is only applied to the non-purgeable shrinker: purgeable objects
> are reclaimed without writeback or GPU idling, so they're cheap enough
> that the core default batch size is fine for them.
> 
> v3:
> - Original patch reworked on top of shrinker split (Matt Brost)
> 
> Assisted-by: LLM
> Signed-off-by: Thomas Hellström <thomas.hellstrom@linux.intel.com>

Reviewed-by: Matthew Brost <matthew.brost@intel.com>

> ---
>  drivers/gpu/drm/xe/xe_shrinker.c | 48 ++++++++++++++++++++++++++++----
>  1 file changed, 42 insertions(+), 6 deletions(-)
> 
> diff --git a/drivers/gpu/drm/xe/xe_shrinker.c b/drivers/gpu/drm/xe/xe_shrinker.c
> index 8e3fe675e0f3..955908b3bdf3 100644
> --- a/drivers/gpu/drm/xe/xe_shrinker.c
> +++ b/drivers/gpu/drm/xe/xe_shrinker.c
> @@ -30,6 +30,8 @@
>   * @shrinkable_pages: Number of pages that are currently shrinkable.
>   * @purgeable_pages: Number of pages that are currently purgeable.
>   * @populated_tts: Number of populated ttm_tts currently shrinkable or purgeable.
> + * @batch_avg: Exponential moving average of the preferred non-purgeable
> + * batch size, based on the average populated ttm_tt size.
>   * @shrink: Pointer to the mm shrinker handling non-purgeable (shrinkable) objects.
>   * @purge_shrink: Pointer to the mm shrinker handling purgeable objects.
>   * @pm_worker: Worker to wake up the device if required.
> @@ -40,6 +42,7 @@ struct xe_shrinker {
>  	long shrinkable_pages;
>  	long purgeable_pages;
>  	long populated_tts;
> +	long batch_avg;
>  	struct shrinker *shrink;
>  	struct shrinker *purge_shrink;
>  	struct work_struct pm_worker;
> @@ -203,6 +206,28 @@ xe_shrinker_count_purgeable(struct shrinker *shrink, struct shrink_control *sc)
>  	return num_pages ? num_pages : SHRINK_EMPTY;
>  }
>  
> +/**
> + * DOC: Batch size calculation
> + *
> + * Update our preferred vmscan batch size for the non-purgeable shrinker
> + * on count passes that allow backup (__GFP_FS), to avoid invoking
> + * scan_objects() for requests too small to free even a single
> + * average-sized GEM object. Our rough estimate for an effective batch
> + * is twice the average number of pages per populated ttm_tt across
> + * the full shrinkable and purgeable population. The factor of two
> + * provides headroom so that most scan invocations can free at least one
> + * GEM object despite variability in object sizes.
> + *
> + * The batch value is updated as an exponential moving average,
> + * (old_batch + avg) / 2, to smooth out sudden changes in the object
> + * population. It is floored at 128 pages, the kernel default
> + * SHRINK_BATCH, to ensure the shrinker remains responsive when there
> + * are very few objects.
> + *
> + * We only do this for the non-purgeable shrinker: purgeable objects are
> + * reclaimed without writeback or GPU idling, so shrinking them is cheap
> + * enough that the core default batch size is fine.
> + */
>  static unsigned long
>  xe_shrinker_count(struct shrinker *shrink, struct shrink_control *sc)
>  {
> @@ -210,15 +235,26 @@ xe_shrinker_count(struct shrinker *shrink, struct shrink_control *sc)
>  	unsigned long num_pages;
>  	bool can_backup = !!(sc->gfp_mask & __GFP_FS);
>  
> +	if (!can_backup)
> +		return SHRINK_EMPTY;
> +
>  	num_pages = ttm_backup_bytes_avail() >> PAGE_SHIFT;
> -	read_lock(&shrinker->lock);
> +	/* Consistently use write_lock() for simplicity. */
> +	write_lock(&shrinker->lock);
>  
> -	if (can_backup)
> -		num_pages = min_t(unsigned long, num_pages, shrinker->shrinkable_pages);
> -	else
> -		num_pages = 0;
> +	num_pages = min_t(unsigned long, num_pages, shrinker->shrinkable_pages);
>  
> -	read_unlock(&shrinker->lock);
> +	if (shrinker->populated_tts) {
> +		unsigned long avg = 2 * (shrinker->shrinkable_pages +
> +					 shrinker->purgeable_pages) /
> +				     shrinker->populated_tts;
> +
> +		shrinker->batch_avg = max((shrinker->batch_avg + (long)avg) >> 1,
> +					  128L /* default SHRINK_BATCH */);
> +		WRITE_ONCE(shrink->batch, shrinker->batch_avg);
> +	}
> +
> +	write_unlock(&shrinker->lock);
>  
>  	return num_pages ? num_pages : SHRINK_EMPTY;
>  }
> -- 
> 2.56.0
>