From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mgamail.intel.com (mgamail.intel.com [192.198.163.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A288D3E0C73 for ; Fri, 10 Jul 2026 21:55:04 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=192.198.163.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1783720507; cv=none; b=uyCy6KUdB/n/7zh7WE3mcaQOrD3SUUVG5t37Olji/U7grzp6bV3R9gtRv6K7vRtBJ/TN69nUV6+p0IJCXE0qc+5aTAheppIo3vSTv0TOM5mGSODWnUVkgrP3/qEAQUR2oKDOX1J73xl5qEH7WYnKJ6HC4VA6dtluHLDohgKnrzI= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1783720507; c=relaxed/simple; bh=fQ9bf+3yhPseJ9wK2nWSw6m5lBFQGHvWX/aYpOlj9Kg=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=SZg5fcMZmaWsBKBeqtDHt4yOpVHnO6y/Zh+Pag/3AmlPxTqwKenYh5BIWJtyFRWeX6rE4yq7IcUZfk2h9iKG03y5BuTkfK1o2t8TVUIywchsaHmalN8r6yyHCB8JQJZax1UWMJSC2Zah88LE/wS0OVXvr92NgLCP7DoR0KQYJhA= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=intel.com; spf=pass smtp.mailfrom=intel.com; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b=CSiDqeJf; arc=none smtp.client-ip=192.198.163.18 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=intel.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=intel.com header.i=@intel.com header.b="CSiDqeJf" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1783720505; x=1815256505; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=fQ9bf+3yhPseJ9wK2nWSw6m5lBFQGHvWX/aYpOlj9Kg=; b=CSiDqeJfB4OZhkJsmTusbL2AuR6sCDn/rtwo2dNrjC1yGQ3DANifGI/U WUv0RdPrpSVXKBMFMEJeRdb0271h0TsKDmh52BpJz4Fa53ciWKmzRUZ/N IHrsnxgOgMG8uVcN/kjxMAjdO7GJZYplazGfEBFLmYp6Ja80ScNqKQWoh JTj9pDF0Ksf3BqPU7ISg9CdB5PcTfoCH7liJPaltkndg7u6hxnS7No98h ZrRY9RFSalSZp/3bDrXkKijCBFPGdPv8KcxiSDfWnaQJB+N6y5/P0NU+A lpPsd8t1egMinZB3fZlhjDgPgUULVuWAGuaBcM7PCWBW/4mbvL0NPO26O g==; X-CSE-ConnectionGUID: z7qtRLoCR/OKHD5CdlaozQ== X-CSE-MsgGUID: X8CE/4bQRdKRtfpqpzVFBA== X-IronPort-AV: E=McAfee;i="6800,10657,11841"; a="83543192" X-IronPort-AV: E=Sophos;i="6.25,154,1779174000"; d="scan'208";a="83543192" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by fmvoesa112.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jul 2026 14:54:54 -0700 X-CSE-ConnectionGUID: PCJC83fiRiiju+qdllIRQQ== X-CSE-MsgGUID: S+dgmViHT82uGoNEUO2//g== X-ExtLoop1: 1 Received: from gsse-cloud1.jf.intel.com ([10.54.39.91]) by fmviesa003-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 10 Jul 2026 14:54:54 -0700 From: Matthew Brost To: intel-xe@lists.freedesktop.org, dri-devel@lists.freedesktop.org Cc: Carlos Santa , Ryan Neph , Christian Koenig , Huang Rui , Matthew Auld , Maarten Lankhorst , Maxime Ripard , Thomas Zimmermann , David Airlie , Simona Vetter , linux-kernel@vger.kernel.org, =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= Subject: [PATCH v2 22/33] drm/xe: Add Kconfig.profile options for BO defrag configuration Date: Fri, 10 Jul 2026 14:54:31 -0700 Message-Id: <20260710215442.2444235-23-matthew.brost@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260710215442.2444235-1-matthew.brost@intel.com> References: <20260710215442.2444235-1-matthew.brost@intel.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add Kconfig.profile options to make XE_BO_DEFRAG_* defines configurable: - DRM_XE_BO_DEFRAG_RECLAIM_BACKOFF_THRESHOLD: Threshold for TTM reclaim backoff - DRM_XE_BO_DEFRAG_SIZE_LIMIT: Maximum number of bytes to defrag per work run - DRM_XE_BO_DEFRAG_INTERVAL_MS: Default delay before defrag worker runs - DRM_XE_BO_DEFRAG_INTERVAL_MAX_MS: Upper bound for defrag worker interval Update xe_bo.c to use these Kconfig options as defaults via #ifdef guards, maintaining backward compatibility with hardcoded values when not configured. Additionally, disable defrag completely when XE_BO_DEFRAG_SIZE_LIMIT is set less than 2M by returning early from xe_bo_defrag_update() (and xe_bo_defrag_remove()) so BOs are never added to the defrag list or the worker kicked; xe_bo_defrag_add() and xe_bo_defrag_schedule() assert the limit is at least 2M. Cc: Carlos Santa Cc: Ryan Neph Cc: Christian Koenig Cc: Huang Rui Cc: Matthew Auld Cc: Maarten Lankhorst Cc: Maxime Ripard Cc: Thomas Zimmermann Cc: David Airlie Cc: Simona Vetter Cc: dri-devel@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org Cc: Thomas Hellström Assisted-by: GitHub_Copilot:claude-haiku-4.5 Signed-off-by: Matthew Brost --- drivers/gpu/drm/xe/Kconfig.profile | 40 ++++++++++++++++++++++++++++++ drivers/gpu/drm/xe/xe_bo.c | 26 +++++++++++++++++++ 2 files changed, 66 insertions(+) diff --git a/drivers/gpu/drm/xe/Kconfig.profile b/drivers/gpu/drm/xe/Kconfig.profile index e07517d120e0..e0aade41f53e 100644 --- a/drivers/gpu/drm/xe/Kconfig.profile +++ b/drivers/gpu/drm/xe/Kconfig.profile @@ -74,3 +74,43 @@ config DRM_XE_ENABLE_SCHEDTIMEOUT_LIMIT to apply to applicable user. For elevated user, all above MIN and MAX values will apply when this configuration is enable to apply limitation. By default limitation is applied. + +config DRM_XE_BO_DEFRAG_RECLAIM_BACKOFF_THRESHOLD + int "BO defrag reclaim backoff threshold" + default 2 + range 1 1000 + help + Once this many BOs are tracked on the device defrag list (i.e. were + backed with a sub-optimal page order), request that the TTM pool backs + off from aggressive reclaim at the beneficial order during populate, + so that allocations make forward progress instead of stalling. + +config DRM_XE_BO_DEFRAG_SIZE_LIMIT + int "Maximum bytes to defrag per work run" + default 33554432 + range 0 1073741824 + help + Maximum number of bytes the defrag worker will process in a single run + before yielding and rescheduling itself. Set to less than large page + size (2M) to disable defrag. A defrag move synchronously reallocates + and re-copies a BO's backing store, which is not free. If a large + number of BOs become eligible at once, processing them all in one + worker run would hold things up for a long, unbounded stretch. + Instead, cap the work done per run and requeue, spreading the defrag + effort out over time. + +config DRM_XE_BO_DEFRAG_INTERVAL_MS + int "Default delay before defrag worker run (ms)" + default 25 + range 1 1000 + help + Default delay before (re)running the defrag worker, in milliseconds. + +config DRM_XE_BO_DEFRAG_INTERVAL_MAX_MS + int "Upper bound for defrag worker interval (ms)" + default 15000 + range 100 1000000 + help + Upper bound for the (exponentially backed off) defrag worker interval, + in milliseconds, so repeated failures don't push the retry arbitrarily + far out. 15000 ms = 15 seconds. diff --git a/drivers/gpu/drm/xe/xe_bo.c b/drivers/gpu/drm/xe/xe_bo.c index c1bbcf0d21ed..405316d0d116 100644 --- a/drivers/gpu/drm/xe/xe_bo.c +++ b/drivers/gpu/drm/xe/xe_bo.c @@ -49,7 +49,11 @@ * aggressive reclaim at the beneficial order during populate, so that * allocations make forward progress instead of stalling. */ +#ifdef CONFIG_DRM_XE_BO_DEFRAG_RECLAIM_BACKOFF_THRESHOLD +#define XE_BO_DEFRAG_RECLAIM_BACKOFF_THRESHOLD CONFIG_DRM_XE_BO_DEFRAG_RECLAIM_BACKOFF_THRESHOLD +#else #define XE_BO_DEFRAG_RECLAIM_BACKOFF_THRESHOLD 2 +#endif /* * Maximum number of bytes of newly (re)allocated backing the defrag worker will @@ -65,17 +69,31 @@ * Only pages a move truly reallocates are charged; pages harvested from the old * backing are free, so an object larger than the budget is upgraded in * budget-sized slices across runs. + * + * Set to 0 to disable defrag completely. */ +#ifdef CONFIG_DRM_XE_BO_DEFRAG_SIZE_LIMIT +#define XE_BO_DEFRAG_SIZE_LIMIT CONFIG_DRM_XE_BO_DEFRAG_SIZE_LIMIT +#else #define XE_BO_DEFRAG_SIZE_LIMIT SZ_32M +#endif /* Default delay before (re)running the defrag worker, in milliseconds. */ +#ifdef CONFIG_DRM_XE_BO_DEFRAG_INTERVAL_MS +#define XE_BO_DEFRAG_INTERVAL_MS CONFIG_DRM_XE_BO_DEFRAG_INTERVAL_MS +#else #define XE_BO_DEFRAG_INTERVAL_MS 25 +#endif /* * Upper bound for the (exponentially backed off) defrag worker interval, in * milliseconds, so repeated failures don't push the retry arbitrarily far out. */ +#ifdef CONFIG_DRM_XE_BO_DEFRAG_INTERVAL_MAX_MS +#define XE_BO_DEFRAG_INTERVAL_MAX_MS CONFIG_DRM_XE_BO_DEFRAG_INTERVAL_MAX_MS +#else #define XE_BO_DEFRAG_INTERVAL_MAX_MS 15000 /* 15 seconds */ +#endif static void xe_bo_defrag_worker(struct work_struct *w); static void xe_place_from_ttm_type(u32 mem_type, struct ttm_place *place); @@ -1120,6 +1138,7 @@ int xe_bo_defrag_init(struct xe_device *xe) static void xe_bo_defrag_schedule(struct xe_device *xe) { + xe_assert(xe, XE_BO_DEFRAG_SIZE_LIMIT >= SZ_2M); schedule_delayed_work(&xe->mem.defrag.worker, msecs_to_jiffies(xe->mem.defrag.interval_ms)); } @@ -1146,6 +1165,7 @@ static void xe_bo_defrag_add(struct xe_bo *bo) xe_bo_assert_held(bo); xe_assert(xe, xe_bo_needs_defrag(bo)); + xe_assert(xe, XE_BO_DEFRAG_SIZE_LIMIT >= SZ_2M); scoped_guard(spinlock, &xe->mem.defrag.lock) { if (list_empty(&bo->defrag_link)) { @@ -1179,6 +1199,9 @@ static void xe_bo_defrag_remove(struct xe_bo *bo) { xe_bo_assert_held(bo); + if (XE_BO_DEFRAG_SIZE_LIMIT < SZ_2M) + return; + if (list_empty(&bo->defrag_link)) return; @@ -1198,6 +1221,9 @@ static void xe_bo_defrag_update(struct xe_bo *bo) { xe_bo_assert_held(bo); + if (XE_BO_DEFRAG_SIZE_LIMIT < SZ_2M) + return; + if (xe_bo_needs_defrag(bo)) xe_bo_defrag_add(bo); else -- 2.34.1