From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 3F20FC44506 for ; Fri, 10 Jul 2026 21:55:07 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 33EF510F98C; Fri, 10 Jul 2026 21:54:56 +0000 (UTC) Authentication-Results: gabe.freedesktop.org; dkim=pass (2048-bit key; unprotected) header.d=intel.com header.i=@intel.com header.b="b1mwNmiA"; dkim-atps=neutral Received: from mgamail.intel.com (mgamail.intel.com [192.198.163.18]) by gabe.freedesktop.org (Postfix) with ESMTPS id A6E4810F974; Fri, 10 Jul 2026 21:54:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1783720495; x=1815256495; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=fQ9bf+3yhPseJ9wK2nWSw6m5lBFQGHvWX/aYpOlj9Kg=; b=b1mwNmiAMZ8sM6uFfTGbOtC3s/xU5ZAGIgxK7aRCKzlvIBRtQdEIw6Or gBFjYGkyN+FkK7ptP6oFVSdsYiR7YYtilUtOEPFQ6Fy3F9te0GqgMjShv dyuuu+ahiz/w8VRs3hyT+YdokeCo1ldykEBFNDLWGsqOW6agWMneyNrSI g70vDAvhMLKiihDQz52mkVmHmk6xlF+Sd08AhzMB62dqJqjoymoP8KzYf ZAvgP4zL+RVKXUup3hwhwpeFqLI9htOK/B8CSyOxfDPveh2YhbOpVSKhh cdWqVevkvr5FcKUi14y0TbAQrTuXDhEp9OcBYQqKYFeC1QOJe1ELDUNKe g==; X-CSE-ConnectionGUID: PkUpzE2WRM+qYGTRCb3Omw== X-CSE-MsgGUID: mzCXfo/WSeKmpt1exEoDRg== X-IronPort-AV: E=McAfee;i="6800,10657,11841"; a="83543197" X-IronPort-AV: E=Sophos;i="6.25,154,1779174000"; d="scan'208";a="83543197" 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> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: intel-xe@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel Xe graphics driver List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-xe-bounces@lists.freedesktop.org Sender: "Intel-xe" 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