mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Niranjana Vishwanathapura <niranjana.vishwanathapura@intel.com>
To: Matthew Brost <matthew.brost@intel.com>
Cc: intel-xe@lists.freedesktop.org, dri-devel@lists.freedesktop.org,
	"Carlos Santa" <carlos.santa@intel.com>,
	"Ryan Neph" <ryanneph@google.com>,
	"Christian Koenig" <christian.koenig@amd.com>,
	"Huang Rui" <ray.huang@amd.com>,
	"Matthew Auld" <matthew.auld@intel.com>,
	"Maarten Lankhorst" <maarten.lankhorst@linux.intel.com>,
	"Maxime Ripard" <mripard@kernel.org>,
	"Thomas Zimmermann" <tzimmermann@suse.de>,
	"David Airlie" <airlied@gmail.com>,
	"Simona Vetter" <simona@ffwll.ch>,
	linux-kernel@vger.kernel.org,
	"Thomas Hellström" <thomas.hellstrom@linux.intel.com>
Subject: Re: [PATCH v3 10/33] drm/ttm: Add full out-of-lock preallocation for ttm_pool_alloc()
Date: Tue, 10 Nov 2026 23:31:53 -0800	[thread overview]
Message-ID: <avQZ6cCNt2H8vBtG@nvishwa1-desk> (raw)
In-Reply-To: <20260711025619.2540575-11-matthew.brost@intel.com>

On Fri, Jul 10, 2026 at 07:55:56PM -0700, Matthew Brost wrote:
>ttm_pool_prealloc_fill() lets a driver preallocate beneficial-order pages
>outside the dma-resv lock for a defragmentation move, so the high-order
>allocations that may stall in reclaim/compaction happen off the critical
>section.  That bag is deliberately partial: it holds only interchangeable
>beneficial-order chunks and the allocator consumes it opportunistically,
>falling back to in-line allocation for everything else.
>
>An ordinary populate of a system-memory buffer object has the same
>problem - the whole backing is allocated under the dma-resv lock - but no
>way to move it out of the critical section, because the existing bag does
>not cover sub-beneficial orders and does not describe a full tt.
>
>Add a "full" flavour of the same preallocation mechanism:
>
>  - struct ttm_pool_prealloc gains a @full flag.  In full mode the bag is
>    an ordered tiling of an entire tt at mixed orders (pool pages
>    included), rather than a set of interchangeable beneficial-order
>    chunks.  The per-chunk order is recorded on the page itself and read
>    back at consume time, so no parallel order array is needed.
>
>  - ttm_pool_prealloc_fill_full() allocates the whole backing for a tt of
>    @num_pages pages up front, mirroring the in-line allocator's order
>    walk (highest order first, capped by the remaining page count).  It
>    reuses the existing unlocked helpers (ttm_pool_prealloc_gfp(),
>    ttm_pool_set_caching()) via a new ttm_pool_take_page() helper that
>    tries a same-order pool page before a fresh system allocation.
>
>  - ttm_pool_prealloc_fini() frees any unconsumed tail at each chunk's own
>    order when @full.
>
>  - ttm_pool_prealloc_fill_full() takes a @beneficial_reclaim_backoff
>    argument, plumbed to ttm_pool_alloc_page(), that lets the caller
>    allocate higher-order chunks without aggressive reclaim/compaction.
>    This suits a driver that upgrades suboptimal pages to beneficial order
>    in place later (e.g. via a background defragmenter) and so has no need
>    to stall the user context reclaiming for contiguity up front.
>
>  - __ttm_pool_alloc() consumes a full bag with a single early branch in
>    ttm_pool_iter_acquire_page(): install the next chunk as-is (order
>    taken from the page) and return; once the best-effort bag is drained
>    the loop falls through to normal in-line allocation.  The defrag
>    harvest and reuse-old phases are inert here as there is no
>    defrag_old_tt.
>
>Like the defrag bag, this is best-effort: a short fill is fine (the pool
>allocates the shortfall in-line) and DMA-alloc pools are unsupported
>(caching is applied on the kernel mapping).  No functional change for
>existing users; the new fill routine has no in-tree caller yet.
>
>Cc: Carlos Santa <carlos.santa@intel.com>
>Cc: Ryan Neph <ryanneph@google.com>
>Cc: Christian Koenig <christian.koenig@amd.com>
>Cc: Huang Rui <ray.huang@amd.com>
>Cc: Matthew Auld <matthew.auld@intel.com>
>Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
>Cc: Maxime Ripard <mripard@kernel.org>
>Cc: Thomas Zimmermann <tzimmermann@suse.de>
>Cc: David Airlie <airlied@gmail.com>
>Cc: Simona Vetter <simona@ffwll.ch>
>Cc: dri-devel@lists.freedesktop.org
>Cc: linux-kernel@vger.kernel.org
>Cc: Thomas Hellström <thomas.hellstrom@linux.intel.com>
>Assisted-by: GitHub_Copilot:claude-opus-4.8
>Signed-off-by: Matthew Brost <matthew.brost@intel.com>
>---
> drivers/gpu/drm/ttm/ttm_pool.c | 232 ++++++++++++++++++++++++++++++++-
> include/drm/ttm/ttm_bo.h       |  19 +--
> include/drm/ttm/ttm_pool.h     |  27 +++-
> 3 files changed, 258 insertions(+), 20 deletions(-)
>
>diff --git a/drivers/gpu/drm/ttm/ttm_pool.c b/drivers/gpu/drm/ttm/ttm_pool.c
>index da7d132c8297..4746f5d8cd7e 100644
>--- a/drivers/gpu/drm/ttm/ttm_pool.c
>+++ b/drivers/gpu/drm/ttm/ttm_pool.c
>@@ -1046,6 +1046,7 @@ int ttm_pool_prealloc_fill(struct ttm_pool *pool, enum ttm_caching tt_caching,
> 	pp->caching = tt_caching;
> 	pp->count = 0;
> 	pp->used = 0;
>+	pp->full = false;
>
> 	/* Nothing to gain without a beneficial order or for DMA-alloc pools. */
> 	if (!order || !count || ttm_pool_uses_dma_alloc(pool))
>@@ -1102,6 +1103,187 @@ int ttm_pool_prealloc_fill(struct ttm_pool *pool, enum ttm_caching tt_caching,
> }
> EXPORT_SYMBOL(ttm_pool_prealloc_fill);
>
>+/*
>+ * Acquire a single *@order chunk, trying a same-order pool page first (already
>+ * carries @caching) then a fresh system allocation (write-back). Runs unlocked.
>+ * When @beneficial_reclaim_backoff is set, higher-order system allocations skip
>+ * aggressive reclaim/compaction (see ttm_pool_alloc_page()).
>+ *
>+ * A fresh system page is write-back and needs the tt's caching applied later in
>+ * bulk; *@need_caching is set true for it and false for a (pre-cached) pool
>+ * page.
>+ *
>+ * On a genuine failure *@order is left untouched (the caller lowers it by one
>+ * and retries). Fault injection instead pretends allocation at (or above) the
>+ * beneficial order failed and lowers *@order to the beneficial order, so the
>+ * caller's next attempt lands below it - mirroring the in-line acquire path's
>+ * fail_beneficial jump and exercising the beneficial_order_failed tracking
>+ * without driving the system into real fragmentation.
>+ *
>+ * Returns NULL if no page of *@order could be obtained.
>+ */
>+static struct page *ttm_pool_take_page(struct ttm_pool *pool,
>+				       enum ttm_caching caching,
>+				       unsigned int *order, gfp_t gfp,
>+				       bool *need_caching,
>+				       bool beneficial_reclaim_backoff)
>+{
>+	unsigned int beneficial = ttm_pool_beneficial_order(pool);
>+	struct ttm_pool_type *pt;
>+	struct page *p;
>+
>+	*need_caching = false;
>+
>+	if (IS_ENABLED(CONFIG_FAULT_INJECTION) && beneficial &&
>+	    *order >= beneficial &&
>+	    should_fail(&beneficial_order_fault_inject, 1)) {
>+		*order = beneficial;
>+		return NULL;
>+	}
>+
>+	pt = ttm_pool_select_type(pool, caching, *order);
>+	if (pt) {
>+		p = ttm_pool_type_take(pt, ttm_pool_nid(pool));
>+		if (p)
>+			return p;	/* pool page already carries @caching */
>+	}
>+
>+	p = ttm_pool_alloc_page(pool, gfp, *order, beneficial_reclaim_backoff);
>+	if (!p)
>+		return NULL;
>+
>+	/* Fresh system page is write-back; caller applies @caching in bulk. */
>+	*need_caching = true;
>+	return p;
>+}
>+
>+/**
>+ * ttm_pool_prealloc_fill_full() - Preallocate a whole tt's backing outside any
>+ * lock
>+ * @pool: The pool to allocate from.
>+ * @tt_caching: The requested cpu-caching for the pages allocated.
>+ * @pp: Prealloc bag to fill; marked @full and tiled with mixed-order chunks.
>+ * @num_pages: Number of 4K pages the tt needs backed.
>+ *
>+ * Unlike ttm_pool_prealloc_fill() (which parks a bag of interchangeable
>+ * beneficial-order defrag chunks), this allocates the ENTIRE backing for a tt
>+ * of @num_pages pages up front, at whatever mix of orders is available (pool
>+ * pages included), so that the subsequent __ttm_pool_alloc() under the dma-resv
>+ * lock merely installs the pages without stalling in reclaim/compaction. The
>+ * chunk orders mirror the in-line allocator's order walk; each chunk's order is
>+ * recorded on the page itself and read back at consume time.
>+ *
>+ * May sleep/reclaim freely as it runs unlocked. When
>+ * @beneficial_reclaim_backoff is set, higher-order chunks are taken without
>+ * aggressive reclaim/compaction: the caller relies on a background
>+ * defragmenter to upgrade to beneficial-order pages in place later, so there
>+ * is no need to stall the user context reclaiming for contiguity here. A short
>+ * fill is fine: the pool falls back to in-line allocation for the shortfall.
>+ * DMA-alloc pools are not supported (the bag stays empty). Returns 0 (release
>+ * with ttm_pool_prealloc_fini()).
>+ */
>+int ttm_pool_prealloc_fill_full(struct ttm_pool *pool,
>+				enum ttm_caching tt_caching,
>+				struct ttm_pool_prealloc *pp,
>+				unsigned int num_pages,
>+				bool beneficial_reclaim_backoff)
>+{
>+	gfp_t gfp = ttm_pool_prealloc_gfp(pool) | __GFP_ZERO |
>+		__GFP_RETRY_MAYFAIL | __GFP_NOWARN;

Assisted-by: LLM

__GFP_RETRY_MAYFAIL is bit confusing here as as ttm_pool_alloc_page()
is expected to suppy it (patch 1). I see that only applies to
beneficial order, but here we have mixed-order and hence it is set
here. May be add some documentation to clarify it?

>+	unsigned int highest = MAX_PAGE_ORDER;
>+	unsigned int remaining = num_pages;
>+	struct page **cpages = NULL;
>+	unsigned int ncpages = 0;
>+	int r;
>+
>+	pp->pages = NULL;
>+	pp->order = 0;
>+	pp->caching = tt_caching;
>+	pp->count = 0;
>+	pp->used = 0;
>+	pp->full = true;
>+
>+	/* Caching is applied on the kernel mapping, so DMA-alloc is unsupported. */
>+	if (!num_pages || ttm_pool_uses_dma_alloc(pool))
>+		return 0;
>+
>+	/* Worst case is one order-0 chunk per page. */
>+	pp->pages = kvzalloc_objs(*pp->pages, num_pages);
>+	if (!pp->pages)
>+		return 0;
>+
>+	/*
>+	 * Fresh write-back chunks get their caching changed in a single
>+	 * set_pages_array_*() after the fill; collect their constituent pages
>+	 * into an unpacked scratch array (one entry per 4K page) since the
>+	 * packed bag holds mixed-order chunks. Cached tts and pool pages need
>+	 * no change (and non-x86 handles caching at map time).
>+	 */
>+	if (IS_ENABLED(CONFIG_X86) && tt_caching != ttm_cached) {
>+		cpages = kvzalloc_objs(*cpages, num_pages);

Same comment as in patch 9.
cpages is tansient memory and unlike patch 9, it is not bounded by 'budget' here.
may be it can be avoided altogether by using a one static 4k page in the
pool and flush it with set_pages_array*() as and when it fills up?

>+		if (!cpages) {
>+			kvfree(pp->pages);
>+			pp->pages = NULL;
>+			return 0;
>+		}
>+	}
>+
>+	while (remaining) {
>+		unsigned int order = min_t(unsigned int, highest,
>+					   __fls(remaining));
>+		bool need_caching;
>+		struct page *p;
>+
>+		for (;;) {
>+			p = ttm_pool_take_page(pool, tt_caching, &order, gfp,
>+					       &need_caching,
>+					       beneficial_reclaim_backoff);
>+			if (p)
>+				break;
>+			if (!order)
>+				goto apply_caching;	/* short fill */
>+			/*
>+			 * Genuine failure: retry one order down. A fault
>+			 * injection lowered @order to the beneficial order
>+			 * above, so this drops it below - landing on a
>+			 * sub-optimal (defrag-worthy) chunk.
>+			 */
>+			order--;
>+		}
>+
>+		pp->pages[pp->count++] = p;
>+		if (cpages && need_caching)
>+			ttm_pool_prealloc_stage_caching(cpages, &ncpages, p,
>+							order);
>+		remaining -= 1u << order;
>+		highest = order;
>+	}
>+
>+apply_caching:
>+	/*
>+	 * Apply the requested caching to every collected page in one shot. On
>+	 * failure the pages' caching is indeterminate, so drop the whole bag
>+	 * (freeing restores write-back) and let the consumer allocate in-line.
>+	 */
>+	r = ttm_pool_prealloc_apply_caching(tt_caching, cpages, ncpages);
>+	kvfree(cpages);
>+	if (r) {
>+		unsigned int i;
>+
>+		for (i = 0; i < pp->count; i++) {
>+			struct page *p = pp->pages[i];
>+
>+			ttm_pool_free_page(pool, tt_caching,
>+					   ttm_pool_page_order_nodma(p), p,
>+					   false);
>+		}
>+		pp->count = 0;
>+	}
>+
>+	return 0;
>+}
>+EXPORT_SYMBOL(ttm_pool_prealloc_fill_full);

It has lot of code common with ttm_pool_prealloc_fill(). May be extract common
code to separate function/s?

>+
> /**
>  * ttm_pool_prealloc_fini() - Release unconsumed preallocated pages
>  * @pool: The pool the pages came from.
>@@ -1111,9 +1293,13 @@ void ttm_pool_prealloc_fini(struct ttm_pool *pool, struct ttm_pool_prealloc *pp)
> {
> 	unsigned int i;
>
>-	for (i = pp->used; i < pp->count; ++i)
>-		ttm_pool_free_page(pool, pp->caching, pp->order, pp->pages[i],
>-				   false);
>+	for (i = pp->used; i < pp->count; ++i) {
>+		struct page *p = pp->pages[i];
>+		unsigned int order = pp->full ?
>+			ttm_pool_page_order_nodma(p) : pp->order;
>+
>+		ttm_pool_free_page(pool, pp->caching, order, p, false);
>+	}
> 	kvfree(pp->pages);
> 	pp->pages = NULL;
> 	pp->count = 0;
>@@ -1251,9 +1437,10 @@ static int ttm_pool_iter_reuse_old(struct ttm_pool_alloc_iter *it)
>
> /*
>  * Acquire a single page for the current order, leaving it in @it->p (NULL on
>- * failure). Tries, in order: a beneficial-order page preallocated outside the
>- * dma-resv lock (defrag), a same-order pool page, then a fresh system
>- * allocation. Fault injection can force the beneficial-order paths to "fail".
>+ * failure). Tries, in order: a chunk from a full out-of-lock prealloc (populate
>+ * of the whole tt), a beneficial-order page preallocated outside the dma-resv
>+ * lock (defrag), a same-order pool page, then a fresh system allocation. Fault
>+ * injection can force the beneficial-order paths to "fail".
>  */
> static void ttm_pool_iter_acquire_page(struct ttm_pool_alloc_iter *it)
> {
>@@ -1262,6 +1449,39 @@ static void ttm_pool_iter_acquire_page(struct ttm_pool_alloc_iter *it)
>
> 	it->p = NULL;
>
>+	/*
>+	 * Full prealloc: the entire backing was allocated (pool + system, at
>+	 * mixed orders) outside the dma-resv lock. Install the next chunk as-is,
>+	 * taking its order from the page. Falls through to in-line allocation
>+	 * once the best-effort bag is drained.
>+	 */
>+	if (pp && pp->full && pp->used < pp->count) {
>+		it->fail_beneficial = false;
>+		it->p = pp->pages[pp->used++];
>+		it->order = ttm_pool_page_order_nodma(it->p);
>+		it->page_caching = it->tt->caching;

Same comment as in 23.
We should ensure caching has not changed here after prefill
(ie., pp->caching == it->tt->caching). Though it is not expected to change
in gem_create_ioctl call (unlike defragmentation case of patch 23),
probably it is still better to check to ensure TTM prealloc() and
pool_alloc_page() interfaces work correctly together?

>+
>+		/*
>+		 * The full prealloc tiles at whatever orders were available
>+		 * without stalling in reclaim. A sub-beneficial chunk only
>+		 * means a sub-optimal backing (defrag-worthy) when it sits in a
>+		 * beneficial-order aligned region that fully fits in the tt -
>+		 * that region could have been a beneficial-order page. A low
>+		 * order in the unaligned trailing tail is expected and must not
>+		 * flag the tt (mirrors ttm_pool_harvest_remaining()).
>+		 */
>+		if (it->beneficial_order && it->order < it->beneficial_order) {
>+			pgoff_t bnr = 1UL << it->beneficial_order;
>+			pgoff_t off = it->tt->num_pages -
>+				      it->alloc->remaining_pages;
>+
>+			if (round_down(off, bnr) + bnr <= it->tt->num_pages)
>+				it->tt->page_flags |=
>+					TTM_TT_FLAG_BENEFICIAL_ORDER_FAILED;
>+		}
>+		return;
>+	}
>+
> 	/*
> 	 * Fault injection: pretend allocation at (or above) the device's
> 	 * beneficial order failed, forcing a sub-optimal backing. Exercises the
>diff --git a/include/drm/ttm/ttm_bo.h b/include/drm/ttm/ttm_bo.h
>index a80304f179ba..52ec7e5c0d2d 100644
>--- a/include/drm/ttm/ttm_bo.h
>+++ b/include/drm/ttm/ttm_bo.h
>@@ -238,14 +238,17 @@ struct ttm_operation_ctx {
> 	 */
> 	s64 defrag_bytes_remaining;
> 	/**
>-	 * @prealloc: Pages preallocated outside the dma-resv lock for a defrag
>-	 * move. The pool allocator consumes these instead of allocating fresh
>-	 * beneficial-order pages under the lock, moving the (potentially
>-	 * reclaim/compaction stalling) high-order allocations out of the
>-	 * critical section. NULL means allocate in-line as usual. The pool
>-	 * silently falls back to in-line allocation for any shortfall. The
>-	 * allocator consumes it for beneficial-order chunks of any populate;
>-	 * drivers only set it for a defrag move.
>+	 * @prealloc: Pages preallocated outside the dma-resv lock. The pool
>+	 * allocator consumes these instead of allocating under the lock, moving
>+	 * the (potentially reclaim/compaction stalling) allocations out of the
>+	 * critical section. NULL means allocate in-line as usual. Two flavours,
>+	 * distinguished by ttm_pool_prealloc::full:
>+	 *   - defrag bag (full=false): a bag of interchangeable beneficial-order
>+	 *     chunks consumed only for beneficial-order chunks of a defrag move.
>+	 *   - full tiling (full=true): the entire backing of the tt, at mixed
>+	 *     orders, consumed for every chunk of an ordinary populate.
>+	 * The allocator silently falls back to in-line allocation for any
>+	 * shortfall.
> 	 */
> 	struct ttm_pool_prealloc *prealloc;
> 	/**
>diff --git a/include/drm/ttm/ttm_pool.h b/include/drm/ttm/ttm_pool.h
>index 71670350eb15..777d5aa08f6a 100644
>--- a/include/drm/ttm/ttm_pool.h
>+++ b/include/drm/ttm/ttm_pool.h
>@@ -83,18 +83,27 @@ void ttm_pool_free(struct ttm_pool *pool, struct ttm_tt *tt);
>
> /**
>  * struct ttm_pool_prealloc - Pages preallocated outside the dma-resv lock
>- * @pages: Array of @count beneficial-order pages (or fewer if a fill fell
>- *         short); each entry is the head page of a 1 << @order chunk.
>- * @order: Page order of every preallocated chunk.
>+ * @pages: Array of @count preallocated chunks; each entry is the head page of a
>+ *         chunk. In defrag mode every chunk is @order pages; in @full mode the
>+ *         chunks tile a whole tt at mixed orders and the per-chunk order is read
>+ *         back from the page itself.
>+ * @order: Page order of every preallocated chunk (defrag mode only; 0 in @full
>+ *         mode where each chunk carries its own order).
>  * @caching: CPU caching applied to the pages, so leftovers can be restored
>  *           to write-back before being freed.
>  * @count: Number of valid entries in @pages.
>  * @used: Number of entries already consumed by the pool allocator.
>+ * @full: When set the bag holds a full, mixed-order tiling of an entire tt
>+ *        (produced by ttm_pool_prealloc_fill_full()) rather than a bag of
>+ *        interchangeable beneficial-order defrag chunks. The pool allocator
>+ *        then drains the bag in order for every populate, taking each chunk's
>+ *        order from the page, and falls back to in-line allocation only for any
>+ *        shortfall.
>  *
>  * Defrag pages are interchangeable, so only a count of beneficial-order chunks
>- * is needed. ttm_pool_prealloc_fill() populates this outside the lock and
>- * __ttm_pool_alloc() drains it; any unused tail is released by
>- * ttm_pool_prealloc_fini().
>+ * is needed. ttm_pool_prealloc_fill() / ttm_pool_prealloc_fill_full() populate
>+ * this outside the lock and __ttm_pool_alloc() drains it; any unused tail is
>+ * released by ttm_pool_prealloc_fini().
>  */
> struct ttm_pool_prealloc {
> 	struct page **pages;
>@@ -102,10 +111,16 @@ struct ttm_pool_prealloc {
> 	enum ttm_caching caching;
> 	unsigned int count;
> 	unsigned int used;
>+	bool full;
> };
>
> int ttm_pool_prealloc_fill(struct ttm_pool *pool, enum ttm_caching tt_caching,
> 			   struct ttm_pool_prealloc *pp, unsigned int count);
>+int ttm_pool_prealloc_fill_full(struct ttm_pool *pool,
>+				enum ttm_caching tt_caching,
>+				struct ttm_pool_prealloc *pp,
>+				unsigned int num_pages,
>+				bool beneficial_reclaim_backoff);
> void ttm_pool_prealloc_fini(struct ttm_pool *pool,
> 			    struct ttm_pool_prealloc *pp);
> unsigned int ttm_pool_prealloc_order(struct ttm_pool *pool);
>-- 
>2.34.1
>

  reply	other threads:[~2026-11-11  7:32 UTC|newest]

Thread overview: 88+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-07-11  2:55 [PATCH v3 00/33] drm/ttm, drm/xe: Minimize dma-resv hold times and defragment sub-optimally backed BOs Matthew Brost
2026-07-11  2:55 ` [PATCH v3 01/33] drm/ttm/pool: Allow backing off reclaim at the beneficial order Matthew Brost
2026-11-06  2:55   ` Niranjana Vishwanathapura
2026-11-19 18:47     ` Matthew Brost
2026-07-11  2:55 ` [PATCH v3 02/33] drm/ttm/pool: Add ttm_pool_page_order_nodma() helper Matthew Brost
2026-11-05 11:27   ` Matthew Auld
2026-11-06  2:30   ` Niranjana Vishwanathapura
2026-07-11  2:55 ` [PATCH v3 03/33] drm/ttm: Record sub-optimal page order allocations in ttm_tt Matthew Brost
2026-11-06  2:34   ` Niranjana Vishwanathapura
2026-11-06 20:06     ` Matthew Brost
2026-07-11  2:55 ` [PATCH v3 04/33] drm/ttm: Introduce ttm_pool_alloc_iter for __ttm_pool_alloc() Matthew Brost
2026-11-06  2:39   ` Niranjana Vishwanathapura
2026-11-19 19:14     ` Matthew Brost
2026-07-11  2:55 ` [PATCH v3 05/33] drm/ttm: Support defragmentation moves Matthew Brost
2026-11-06  2:51   ` Niranjana Vishwanathapura
2026-11-19 20:15     ` Matthew Brost
2026-07-11  2:55 ` [PATCH v3 06/33] drm/ttm: Add fault injection for beneficial-order allocation failures Matthew Brost
2026-11-06  2:54   ` Niranjana Vishwanathapura
2026-11-19 20:49     ` Matthew Brost
2026-07-11  2:55 ` [PATCH v3 07/33] drm/ttm: Harvest beneficial-order pages on defragmentation moves Matthew Brost
2026-11-10  2:37   ` Niranjana Vishwanathapura
2026-11-19 21:39     ` Matthew Brost
2026-07-11  2:55 ` [PATCH v3 08/33] drm/ttm: Bound page (re)allocation per defragmentation move Matthew Brost
2026-11-10  2:44   ` Niranjana Vishwanathapura
2026-11-20  2:14     ` Matthew Brost
2026-07-11  2:55 ` [PATCH v3 09/33] drm/ttm: Preallocate beneficial-order defrag pages outside the lock Matthew Brost
2026-11-11  0:29   ` Niranjana Vishwanathapura
2026-11-11  7:49   ` Niranjana Vishwanathapura
2026-11-20  2:29     ` Matthew Brost
2026-07-11  2:55 ` [PATCH v3 10/33] drm/ttm: Add full out-of-lock preallocation for ttm_pool_alloc() Matthew Brost
2026-11-11  7:31   ` Niranjana Vishwanathapura [this message]
2026-11-20  5:48     ` Matthew Brost
2026-07-11  2:56 ` [PATCH v3 15/33] drm/xe: Track BOs backed at a sub-optimal page order Matthew Brost
2026-11-07  4:49   ` Niranjana Vishwanathapura
2026-11-20  6:02     ` Matthew Brost
2026-07-11  2:56 ` [PATCH v3 16/33] drm/xe: Back off beneficial-order reclaim under defrag pressure Matthew Brost
2026-11-07  5:02   ` Niranjana Vishwanathapura
2026-11-20  6:08     ` Matthew Brost
2026-07-11  2:56 ` [PATCH v3 17/33] drm/xe: Add xe_migrate_copy_defrag() for on-GPU defrag copies Matthew Brost
2026-11-03 12:58   ` Matthew Auld
2026-11-03 20:08     ` Matthew Brost
2026-11-04 12:37       ` Matthew Auld
2026-11-20  6:11         ` Matthew Brost
2026-11-07  5:07   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 18/33] drm/xe: Handle defrag moves in xe_bo_move() Matthew Brost
2026-11-07  5:12   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 19/33] drm/xe: Skip self-copies for borrowed pages on defrag moves Matthew Brost
2026-11-10  4:25   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 20/33] drm/xe: Add a page defragmentation worker Matthew Brost
2026-11-07  5:27   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 21/33] drm/xe: Add defrag GT stats Matthew Brost
2026-11-09  1:10   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 22/33] drm/xe: Add Kconfig.profile options for BO defrag configuration Matthew Brost
2026-11-09  1:31   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 23/33] drm/xe: Defrag using out-of-lock page preallocation Matthew Brost
2026-11-11  0:39   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 24/33] drm/xe: Add defrag profiling tracepoints Matthew Brost
2026-11-09  4:34   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 25/33] drm/xe: Preallocate system BO backing outside the dma-resv lock Matthew Brost
2026-11-11  7:36   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 26/33] drm/xe: Add tracepoint for xe_gem_create_ioctl Matthew Brost
2026-11-11  7:37   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 27/33] drm/xe: Add IOVA-based xe_res_cursor variant Matthew Brost
2026-11-04 12:23   ` Matthew Auld
2026-11-13  6:14   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 28/33] drm/xe: Use IOVA-based DMA mapping for eligible tt BOs Matthew Brost
2026-11-03 19:00   ` Matthew Auld
2026-11-03 20:21     ` Matthew Brost
2026-11-04 11:39       ` Matthew Auld
2026-11-05  3:04         ` Matthew Brost
2026-11-13  6:28   ` Niranjana Vishwanathapura
2026-11-13 20:09     ` Matthew Brost
2026-11-16  4:10       ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 29/33] drm/xe: Add per-device dependency scheduler for IOVA defrag finalize Matthew Brost
2026-11-14  1:47   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 30/33] drm/xe: Add packed copy-step IOVA mapping for defrag Matthew Brost
2026-11-14  1:52   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 31/33] drm/xe: Blit src-natural to dst-packed for defrag-IOVA copies Matthew Brost
2026-11-14  1:57   ` Niranjana Vishwanathapura
2026-11-16  0:41   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 32/33] drm/xe: Finalize defrag-IOVA moves with post-copy job Matthew Brost
2026-11-14  2:02   ` Niranjana Vishwanathapura
2026-07-11  2:56 ` [PATCH v3 33/33] drm/amdgpu: Preallocate system BO pages outside the reservation lock Matthew Brost
2026-07-11 10:46   ` Christian König
2026-07-13 20:24     ` Matthew Brost
2026-07-14  9:17       ` Christian König
2026-07-14 15:15         ` Matthew Brost
2026-11-16  1:01 ` [PATCH v3 00/33] drm/ttm, drm/xe: Minimize dma-resv hold times and defragment sub-optimally backed BOs Niranjana Vishwanathapura

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=avQZ6cCNt2H8vBtG@nvishwa1-desk \
    --to=niranjana.vishwanathapura@intel.com \
    --cc=airlied@gmail.com \
    --cc=carlos.santa@intel.com \
    --cc=christian.koenig@amd.com \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=intel-xe@lists.freedesktop.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=maarten.lankhorst@linux.intel.com \
    --cc=matthew.auld@intel.com \
    --cc=matthew.brost@intel.com \
    --cc=mripard@kernel.org \
    --cc=ray.huang@amd.com \
    --cc=ryanneph@google.com \
    --cc=simona@ffwll.ch \
    --cc=thomas.hellstrom@linux.intel.com \
    --cc=tzimmermann@suse.de \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®