Re: [PATCHSET wq/for-6.8] workqueue: Implement system-wide max_active for unbound workqueues

[Naohiro Aota]

On Wed, Dec 20, 2023 at 04:24:31PM +0900, Tejun Heo wrote:
> Hello,
> 
> A pool_workqueue (pwq) represents the connection between a workqueue and a
> worker_pool. One of the roles that a pwq plays is enforcement of the
> max_active concurrency limit. Before 636b927eba5b ("workqueue: Make unbound
> workqueues to use per-cpu pool_workqueues"), there was one pwq per each CPU
> for per-cpu workqueues and per each NUMA node for unbound workqueues, which
> was a natural result of per-cpu workqueues being served by per-cpu pools and
> unbound by per-NUMA pools.
> 
> In terms of max_active enforcement, this was, while not perfect, workable.
> For per-cpu workqueues, it was fine. For unbound, it wasn't great in that
> NUMA machines would get max_active that's multiplied by the number of nodes
> but didn't cause huge problems because NUMA machines are relatively rare and
> the node count is usually pretty low.
> 
> However, cache layouts are more complex now and sharing a worker pool across
> a whole node didn't really work well for unbound workqueues. Thus, a series
> of commits culminating on 8639ecebc9b1 ("workqueue: Make unbound workqueues
> to use per-cpu pool_workqueues") implemented more flexible affinity
> mechanism for unbound workqueues which enables using e.g. last-level-cache
> aligned pools. In the process, 636b927eba5b ("workqueue: Make unbound
> workqueues to use per-cpu pool_workqueues") made unbound workqueues use
> per-cpu pwqs like per-cpu workqueues.
> 
> While the change was necessary to enable more flexible affinity scopes, this
> came with the side effect of blowing up the effective max_active for unbound
> workqueues. Before, the effective max_active for unbound workqueues was
> multiplied by the number of nodes. After, by the number of CPUs.
> 
> 636b927eba5b ("workqueue: Make unbound workqueues to use per-cpu
> pool_workqueues") claims that this should generally be okay. It is okay for
> users which self-regulates concurrency level which are the vast majority;
> however, there are enough use cases which actually depend on max_active to
> prevent the level of concurrency from going bonkers including several IO
> handling workqueues that can issue a work item for each in-flight IO. With
> targeted benchmarks, the misbehavior can easily be exposed as reported in
> http://lkml.kernel.org/r/dbu6wiwu3sdhmhikb2w6lns7b27gbobfavhjj57kwi2quafgwl@htjcc5oikcr3.
> 
> Unfortunately, there is no way to express what these use cases need using
> per-cpu max_active. A CPU may issue most of in-flight IOs, so we don't want
> to set max_active too low but as soon as we increase max_active a bit, we
> can end up with unreasonable number of in-flight work items when many CPUs
> issue IOs at the same time. ie. The acceptable lowest max_active is higher
> than the acceptable highest max_active.
> 
> Ideally, max_active for an unbound workqueue should be system-wide so that
> the users can regulate the total level of concurrency regardless of node and
> cache layout. The reasons workqueue hasn't implemented that yet are:
> 
> - One max_active enforcement decouples from pool boundaires, chaining
>   execution after a work item finishes requires inter-pool operations which
>   would require lock dancing, which is nasty.
> 
> - Sharing a single nr_active count across the whole system can be pretty
>   expensive on NUMA machines.
> 
> - Per-pwq enforcement had been more or less okay while we were using
>   per-node pools.
> 
> It looks like we no longer can avoid decoupling max_active enforcement from
> pool boundaries. This patchset implements system-wide nr_active mechanism
> with the following design characteristics:
> 
> - To avoid sharing a single counter across multiple nodes, the configured
>   max_active is split across nodes according to the proportion of online
>   CPUs per node. e.g. A node with twice more online CPUs will get twice
>   higher portion of max_active.
> 
> - Workqueue used to be able to process a chain of interdependent work items
>   which is as long as max_active. We can't do this anymore as max_active is
>   distributed across the nodes. Instead, a new parameter min_active is
>   introduced which determines the minimum level of concurrency within a node
>   regardless of how max_active distribution comes out to be.
> 
>   It is set to the smaller of max_active and WQ_DFL_MIN_ACTIVE which is 8.
>   This can lead to higher effective max_weight than configured and also
>   deadlocks if a workqueue was depending on being able to handle chains of
>   interdependent work items that are longer than 8.
> 
>   I believe these should be fine given that the number of CPUs in each NUMA
>   node is usually higher than 8 and work item chain longer than 8 is pretty
>   unlikely. However, if these assumptions turn out to be wrong, we'll need
>   to add an interface to adjust min_active.
> 
> - Each unbound wq has an array of struct wq_node_nr_active which tracks
>   per-node nr_active. When its pwq wants to run a work item, it has to
>   obtain the matching node's nr_active. If over the node's max_active, the
>   pwq is queued on wq_node_nr_active->pending_pwqs. As work items finish,
>   the completion path round-robins the pending pwqs activating the first
>   inactive work item of each, which involves some pool lock dancing and
>   kicking other pools. It's not the simplest code but doesn't look too bad.
> 
> This patchset includes the following patches:
> 
>  0001-workqueue-Move-pwq-max_active-to-wq-max_active.patch
>  0002-workqueue-Factor-out-pwq_is_empty.patch
>  0003-workqueue-Replace-pwq_activate_inactive_work-with-__.patch
>  0004-workqueue-Move-nr_active-handling-into-helpers.patch
>  0005-workqueue-Make-wq_adjust_max_active-round-robin-pwqs.patch
>  0006-workqueue-Add-first_possible_node-and-node_nr_cpus.patch
>  0007-workqueue-Move-pwq_dec_nr_in_flight-to-the-end-of-wo.patch
>  0008-workqueue-Introduce-struct-wq_node_nr_active.patch
>  0009-workqueue-Implement-system-wide-nr_active-enforcemen.patch
>  0010-workqueue-Reimplement-ordered-workqueue-using-shared.patch
> 
> This pachset is also available in the following git branch.
> 
>  https://git.kernel.org/pub/scm/linux/kernel/git/tj/wq.git unbound-system-wide-max_active

Thank you for the series. I applied the patches on btrfs's development tree
below, and ran the benchmark.

https://gitlab.com/kdave/btrfs-devel.git misc-next

- misc-next, numa=off (baseline)
  WRITE: bw=1117MiB/s (1171MB/s), 1117MiB/s-1117MiB/s (1171MB/s-1171MB/s), io=332GiB (356GB), run=304322-304322msec
- misc-next + wq patches, numa=off
  WRITE: bw=1866MiB/s (1957MB/s), 1866MiB/s-1866MiB/s (1957MB/s-1957MB/s), io=684GiB (735GB), run=375472-375472msec

So, the patches surely improved the performance. However, as show below, it
is still lower than reverting previous workqueue patches. The reverting is
done by reverse applying output of "git diff 4cbfd3de737b
kernel/workqueue.c kernel/workqueue_internal.h include/linux/workqueue*
init/main.c"

- misc-next + wq reverted, numa=off
  WRITE: bw=2472MiB/s (2592MB/s), 2472MiB/s-2472MiB/s (2592MB/s-2592MB/s), io=732GiB (786GB), run=303257-303257msec

I also tested Lai Jiangshan's patches as below.

https://lore.kernel.org/all/20231227145143.2399-1-jiangshanlai@xxxxxxxxx/

- misc-next+wq another approach, numa=off
  WRITE: bw=1697MiB/s (1780MB/s), 1697MiB/s-1697MiB/s (1780MB/s-1780MB/s), io=678GiB (728GB), run=409213-409213msec

> 
> diffstat follows.
> 
>  include/linux/workqueue.h |   35 ++-
>  kernel/workqueue.c        |  669 ++++++++++++++++++++++++++++++++++++++++++++++++-------------
>  2 files changed, 565 insertions(+), 139 deletions(-)
> 
> --
> tejun