Re: [PATCH net-next v6 2/2] net: macb: distribute evenly Tx SRAM segments
From: Théo Lebrun
Date: Fri Nov 13 2026 - 13:35:08 EST
On Fri Nov 13, 2026 at 6:32 PM CET, Théo Lebrun wrote:
> +/*
> + * Distribute evenly available segments across queues. The computation is
> + * complex because (1) segments are counted in powers of two and (2) a queue
> + * can only use up to 8 segments. There are four types of cases:
> + * - Sharing all segments equally is doable. Take num_queues=4 and
> + * num_segments=16. Each queue will get 2^2=4 segments.
> + * - Sharing all segments is doable. Take num_queues=5 and num_segments=16.
> + * Three queues will get 2^2=4 segments and two will get 2^1=2 segments.
> + * - Sharing all segments is not doable because not enough queues are
> + * available. Take num_queues=1 and num_segments=16; queue 0 can only have 8
> + * segments.
> + * - Sharing all segments is not doable because not enough segments are
> + * available. Take num_queues=4 and num_segments=2.
> + *
> + * We start by computing the power each queue will have. For num_queues=5 and
> + * num_segments=16, each queue will have at least 2^1 segments. That leaves us
> + * with remaining_segments=6. If we increase the power for a queue, we get a
> + * delta of 2 (2^2-2^1). The first three queues will therefore be advantaged
> + * and each have 2^2 segments. The remaining 2 queues will only have 2^1
> + * segments.
> + */
> +static u32 gem_sram_distribute_segments(unsigned int num_queues,
> + unsigned int num_segments)
> +{
> + unsigned int pow, remaining_segments, i;
> + unsigned int num_advantaged_queues = 0;
> + u32 val = 0;
> +
> + /* When growing the max # of queues, make sure to return a u64 here and
> + * to write into GEM_TXQSEGALLOC_UPPER.
> + */
> + static_assert(MACB_MAX_QUEUES == 8);
> +
> + /* pow=0 for all queues. ilog2(0) is dangerous. */
> + if (num_queues >= num_segments)
> + return 0;
> +
> + pow = min_t(unsigned int, ilog2(num_segments / num_queues), 3);
> + remaining_segments = num_segments - num_queues * (1U << pow);
> +
> + /* We can only distribute remaining segments if (1) there are remaining
> + * segments and (2) we did not reach the max segments per queue (2^3).
> + */
> + if (remaining_segments != 0 && pow != 3) {
> + unsigned int delta = (1U << (pow + 1)) - (1U << pow);
> +
> + num_advantaged_queues = remaining_segments / delta;
> + }
> +
> + for (i = 0; i < num_advantaged_queues; i++)
> + val |= field_prep(GEM_TXQSEGALLOC_MASK(i), pow + 1);
> + for (i = num_advantaged_queues; i < num_queues; i++)
> + val |= field_prep(GEM_TXQSEGALLOC_MASK(i), pow);
> +
> + return val;
> +}
This implementation doesn't use all segments if
num_segments > 8*num_queues. Reported by Nicolai and discussed here [0].
I don't think any hardware lands in that case, but let's fix the bug.
I will let some time pass before iterating.
[0]: https://lore.kernel.org/all/1113dac19771ff7881b60bfdd14b0af6@xxxxxxxxxxx/
Thanks,
--
Théo Lebrun, Bootlin
Embedded Linux and Kernel engineering
https://bootlin.com