Re: [PATCH v2 4/5] xfs: steer allocation using write stream

[Dave Chinner <dgc@kernel.org>]

On Mon, Mar 09, 2026 at 10:59:43AM +0530, Kanchan Joshi wrote:
> When write stream is set on the file, override the default
> directory-locality heuristic with a new heuristic that maps
> available AGs into streams.
>
> Isolating distinct write streams into dedicated allocation groups helps
> in reducing the block interleaving of concurrent writers. Keeping these
> streams spatially separated reduces AGF lock contention and logical file
> fragmentation.

a.k.a. the XFS filestreams allocator.

i.e. we already have an allocator that performs this exact locality
mapping. See xfs_inode_is_filestream() and the allocator code path
that goes this way:

xfs_bmap_btalloc()
  xfs_bmap_btalloc_filestreams()
    xfs_filestream_select_ag()

Please integrate this write stream mapping functionality into that
allocator rather than hacking a new, almost identical allocator
policy into XFS.

filestreams currently uses the parent inode number as the stream ID
and maps that to an AG. It should be relatively trivial to use the
ip->i_write_stream as the stream ID instead of the parent inode.

> If AGs are fewer than write streams, write streams are distributed into
> available AGs in round robin fashion.
> If not, available AGs are partitioned into write streams. Since each
> write stream maps to a partition of multiple contiguous AGs, the inode hash
> is used to choose the specific AG within the stream partition. This can
> help with intra-stream concurency when multiple files are being written in
> a single stream that has 2 or more AGs.
> 
> Example: 8 Allocation Groups, 4 Streams
> Partition Size = 2 AGs per Stream
> 
>    Stream 1 (ID: 1)         Stream 2 (ID: 2)         Streams 3 & 4
>  +---------+---------+    +---------+---------+    +-------------
>  |   AG0   |   AG1   |    |   AG2   |   AG3   |    |  AG4...AG7
>  +---------+---------+    +---------+---------+    +-------------
>       ^         ^              ^         ^
>       |         |              |         |
>       | File B (ino: 101)      | File D (ino: 201)
>       | 101 % 2 = 1 -> AG 1    | 201 % 2 = 1 -> AG 3
>       |                        |
>  File A (ino: 100)        File C (ino: 200)
>  100 % 2 = 0 -> AG 0      200 % 2 = 0 -> AG 2
> 
> If AGs can not be evenly distributed among streams, the last stream will
> absorb the remaining AGs.

Yeah, this should all be hidden behind xfs_filestream_select_ag()
when ip->i_write_stream is set....

> Note that there are no hard boundaries; this only provides explicit
> routing hint to xfs allocator so that it can group/isolate files in the way
> application has decided to group/isolate. We still try to preserve file
> contiguity, and the full space can be utilized even with a single stream.

Yes, that's pretty much exactly what the filestreams allocator was
designed to do. It's a whole lot more dynamic that what you are
trying to do above and is not limited fixed AGs for streams - as
soon as an AG is out of space, it will select the AG with the most
free space for the stream and keep that relationship until that AG
is out of space.

IOWs, filestreams does not limit a stream to a fixed number of AGs.
All it does is keep IO with the same stream ID in the same AG until
the AG is full and, as much as possible, prevents multiple streams
from using the same AG.

-Dave.
-- 
Dave Chinner
dgc@kernel.org