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: Fri, 20 Nov 2026 21:03:22 -0800 [thread overview]
Message-ID: <awEmGqzlcitPQtIv@nvishwa1-desk> (raw)
In-Reply-To: <av/fJ28fT1/3FtD1@gsse-cloud1.jf.intel.com>
On Thu, Nov 19, 2026 at 09:48:23PM -0800, Matthew Brost wrote:
>On Tue, Nov 10, 2026 at 11:31:53PM -0800, Niranjana Vishwanathapura wrote:
>> 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
>>
>
>Yes.
>
>> __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?
>>
>
>Ye, this is a bit confusing. ttm_pool_alloc_page will change these flags
>based beneficial_reclaim_backoff / beneficial_order. In general I chose
>to set __GFP_RETRY_MAYFAIL here as a default to avoid the prealloc to
>avoid any chance of triggering OOM - i.e., if prealloc fails for
>whatever reason we fall back the traditional TTM alloc path which I
>think is correct.
>
>So maybe '__GFP_RETRY_MAYFAIL is set to never trigger OOM on prealloc'.
>
Sounds good.
>> > + 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.
>
>It is not bounded by any budget rather by the number pages in the BO
>size.
>
I mean in defragment case, it is bounded by XE_BO_DEFRAG_SIZE_LIMIT, but
in gem_create ioctl, it is not. So, for a 1GB BO, the required memory for
this array is 2MB.
>> 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?
>>
>
>I think that is the wrong trade. set_pages_array on x86 does some
>hardware interaction which is rather expensive, thus the entire reason
>TTM pool exist to avoid calling set_pages_array on every alloc / free.
>i.e., more tansient memory vs 1 hardware interaction is the right trade.
>
I meant batched set_pages_array*() call with fixed batch size (not for
every page). But I agree, we shouldn't complicate it unless it is really
required. So, code is fine as is.
>> > + 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?
>
>I see what you mean, but the algorithms are different. One tries to
>obtain N beneficially ordered pages, while the other fills an array with
>any set of pages regardless of order.
>
>I'm hesitant to force the code into helpers or create a single unified
>function with conditionals just to save 70 lines of code. In my opinion,
>the abstraction is already at the right level.
>
Ok
>>
>> > +
>> > /**
>> > * 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?
>>
>
>We don't have formalized assert framework in TTM like we do in Xe but
>perhaps we should - I'd like add one in a follow up as there as so many
>undocumented invarients in TTM...
>
>So...
>
>/* TODO: formalize invarients in a common TTM assert framework */
>WARN_ON(it->tt->caching != pp->pp->caching)?
>
In gem_create ioctl case (which is the case here), the tt->caching is not
expected to change between prefill and allocation (whereas in defragmentation
case of patch 23, it can). So, yes a WARN_ON should be good here.
But given it is ttm code, may be in both cases (gem_create ioctl and
defragmentation), we should probably fall back to regular allocation
and free the preallocated pages?
Niranjana
>Matt
>
>> > +
>> > + /*
>> > + * 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
>> >
next prev parent reply other threads:[~2026-11-21 5:03 UTC|newest]
Thread overview: 91+ 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-11-20 23:09 ` Niranjana Vishwanathapura
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-11-20 20:37 ` Niranjana Vishwanathapura
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
2026-11-20 5:48 ` Matthew Brost
2026-11-21 5:03 ` Niranjana Vishwanathapura [this message]
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=awEmGqzlcitPQtIv@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®