On Wed, Oct 21, 2020 at 11:11:00PM -0700, Darrick J. Wong wrote:
> On Thu, Oct 22, 2020 at 04:15:34PM +1100, Dave Chinner wrote:
> > +static void
> > +traverse_function(
> > + struct workqueue *wq,
> > + xfs_agnumber_t agno,
> > + void *arg)
> > +{
> > + struct ino_tree_node *irec;
> > prefetch_args_t *pf_args = arg;
> > + struct workqueue lwq;
> > + struct xfs_mount *mp = wq->wq_ctx;
> > +
> >
> > wait_for_inode_prefetch(pf_args);
> >
> > if (verbose)
> > do_log(_(" - agno = %d\n"), agno);
> >
> > + /*
> > + * The more AGs we have in flight at once, the fewer processing threads
> > + * per AG. This means we don't overwhelm the machine with hundreds of
> > + * threads when we start acting on lots of AGs at once. We just want
> > + * enough that we can keep multiple CPUs busy across multiple AGs.
> > + */
> > + workqueue_create_bound(&lwq, mp, ag_stride, 1000);
>
> Eeeeee, magic number! :)
>
> /me tosses in obligatory hand-wringing about 2000 CPU systems running
> out of work. How about ag_stride * 50 or something? :P
ag_stride already determines concurrency via how many AGs are being
scanned at once. However, it provides no insight into the depth of
the queue we need to use per AG.
What this magic number does is bound how deep the work queue gets
before we ask another worker thread to start also processing the
queue. We've already got async threads doing inode prefetch, so the
bound here throttles the rate at which inodes are
prefetched into the buffer cache. In general, we're going to be IO
bound and waiting on readahead rather than throttling on processing
the inodes, so all this bound is doing is preventing readahead from
running too far ahead of processing and potentially causing cache
thrashing.
However, we don't want to go using lots of threads to parallelise
the work within the AG when we have already parallelised across AGs.
We want the initial worker thread per AG to just keep working away
burning CPU while the prefetch code is blocking waiting for more
inodes from disk. Then we get another burst of work being queued,
and so on.
Hence the queue needs to be quite deep so that we can soak up the
bursts of processing that readahead triggers without asking lots of
worker threads to do work. However, if the worker thread hits some
big directories and starts falling behind readahead, that's when it
will hit the maximum queue depth and kick another thread to do work.
IOWs, the queue depth needs to be deep enough to prevent bursts from
triggering extra workers from running, but shallow enough that extra
workers will be scheduled when processing falls behind readahead.
I really don't have a good way to automatically calculate this
depth. I just figure that if we have a 1000 inodes queued up for
processing, we really should kick another thread to start working on
them. It's a simple solution, so I'd like to see if we have problems
with this simple threshold before we try to replace the magic number
with a magic heuristic....
Cheers,
Dave.
--
Dave Chinner
david@xxxxxxxxxxxxx
