MIME-Version: 1.0
References: 
 <CA+hUKG+m4xV0LMoH2c=oRAdEXuCnh+tGBTWa7uFeFMGgTLAw+Q@mail.gmail.com>
 <it7fexpclowjku57bsdh4uqr366wa2fxtq5ahzxczoxonmbh5s@g2f5oesiakzq>
 <CA+hUKGJULUTkT2LpeHTSt3KHbJrYNBT-kj1-OhMRV_PnUQ_57A@mail.gmail.com>
 <CA+q6zcW0qh2aPKg0z58mp-Ba8avp7MWkS00ADrOOv=CBzJJMLA@mail.gmail.com>
 <CA+hUKGJLe-0E-wZ-is78CEHhjbC=ihMVCQLoN1dmD-j05s9qRg@mail.gmail.com>
 <pdrbpbvhscwckb6nqkfgoo7o63nnmeq7taaazgfi3bk627gb6p@rzcauoqabb3k>
 <CA+hUKG+P80oR7yy5-67uHqwBWr9rux69BkQF9fwz=f0LuDn3Rw@mail.gmail.com>
 <CA+hUKGKgVhLVS4Pne8cTR0f=tE8GtF4-CvY2HMDOJEm7w0iXfA@mail.gmail.com>
 <20260328095204.5tsq5bldugeumrtf@erthalion>
 <CA+hUKGLUZ51zkxUoBvANcLdvz8DjS_85=6985HE8gLuNtBxX7Q@mail.gmail.com>
 <jp7lhn2wng5mlhn3jvn4t6nmr23l6bnim5af3qslnoguevfqqz@d7cvksm62j4j>
In-Reply-To: <jp7lhn2wng5mlhn3jvn4t6nmr23l6bnim5af3qslnoguevfqqz@d7cvksm62j4j>
From: Thomas Munro <thomas.munro@gmail.com>
Date: Tue, 7 Apr 2026 22:39:37 +1200
Message-ID: 
 <CA+hUKGLp_yPztSoQkmRe1kFk1M5JNr7b+07cc+46AVg=VoKC-Q@mail.gmail.com>
Subject: Re: Automatically sizing the IO worker pool
To: Andres Freund <andres@anarazel.de>
Cc: Dmitry Dolgov <9erthalion6@gmail.com>,
	PostgreSQL Hackers <pgsql-hackers@lists.postgresql.org>
Content-Type: multipart/mixed; boundary="0000000000009e581e064edc682e"
Archived-At: 
 <https://www.postgresql.org/message-id/CA%2BhUKGLp_yPztSoQkmRe1kFk1M5JNr7b%2B07cc%2B46AVg%3DVoKC-Q%40mail.gmail.com>
Precedence: bulk

--0000000000009e581e064edc682e
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Tue, Apr 7, 2026 at 6:14=E2=80=AFAM Andres Freund <andres@anarazel.de> w=
rote:
> On 2026-04-07 03:02:52 +1200, Thomas Munro wrote:
> > Here's an updated patch.  It's mostly just rebased over the recent
> > firehose, but with lots of comments and a few names (hopefully)
> > improved.  There is one code change to highlight though:
> >
> > maybe_start_io_workers() knows when it's not allowed to create new
> > workers, an interesting case being FatalError before we have started
> > the new world.
>
> *worker, I assume?

Thanks for the review and testing!

I meant the new world when "we're already starting up again", as in
this pre-existing code from master:

    /*
     * Don't start new workers if we're in the shutdown phase of a crash
     * restart. But we *do* need to start if we're already starting up agai=
n.
     */
    if (FatalError && pmState >=3D PM_STOP_BACKENDS)
        return;

> > The previous coding of DetermineSleepTime() didn't
> > know about that, so it could return 0 (don't sleep), and then the
> > postmaster could busy-wait for restart progress.
>
> In master or the prior version of your patch?

master

This code that checks AbortStartTime and overrides the sleep time.
But it wouldn't be entered if FatalError is true but StartWorkerNeeded
or HaveCrashedWorker also happens to be true.  Maybe that's OK but I
found it odd.

https://github.com/postgres/postgres/blob/a006bc7b1699d952afcb6d786343e8bf0=
ecc61d6/src/backend/postmaster/postmaster.c#L1567

> > Maybe there were
> > other cases like that, but in general DetermineSleepTime() and
> > maybe_start_io_workers() really need to be 100% in agreement.  So I
> > have moved that knowledge into a new function
> > maybe_start_io_workers_scheduled_at().  Both DetermineSleepTime() and
> > maybe_start_io_workers() call that so there is a single source of
> > truth.
> >
> > I think I got confused about that because it's not that obvious why
> > the existing code doesn't test FatalError.
> >
> > I thought of a slightly bigger refactoring that might deconfuse
> > DetermineSleepTime() a bit more.  Probably material for the next
> > cycle, but basically the idea is to stop using a bunch of different
> > conditions and different units of time and convert the whole thing to
> > a simple find-the-lowest-time function.  I kept that separate.
> >
> > I'll post a new version of the patch that was v3-0002 separately.
>
>
> > From 6c5d16a15add62c68bb7f9c7b6a1e3bde1f406d8 Mon Sep 17 00:00:00 2001
> > From: Thomas Munro <thomas.munro@gmail.com>
> > Date: Sat, 22 Mar 2025 00:36:49 +1300
> > Subject: [PATCH v4 1/2] aio: Adjust I/O worker pool size automatically.
> >
> > The size of the I/O worker pool used to implement io_method=3Dworker wa=
s
> > previously controlled by the io_workers setting, defaulting to 3.  It
> > was hard to know how to tune it effectively.  It is now replaced with:
> >
> >   io_min_workers=3D1
> >   io_max_workers=3D8 (up to 32)
> >   io_worker_idle_timeout=3D60s
> >   io_worker_launch_interval=3D100ms
>
> I'm a bit concerned about defaulting to io_min_workers=3D1. That means in=
 an
> intermittent workload, there will be no IO concurrency for short running =
but
> IO intensive queries, while having the dispatch overhead to the worker.  =
It
> can still be a win if the query is CPU intensive, but far from all are.
>
> I'd therefore argue that the minimum ought to be at least 2.

WFM.

> > diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmast=
er/postmaster.c
> > index 6f13e8f40a0..c42564500c6 100644
> > --- a/src/backend/postmaster/postmaster.c
> > +++ b/src/backend/postmaster/postmaster.c
>
>
> > @@ -1555,14 +1558,13 @@ checkControlFile(void)
> >  static int
> >  DetermineSleepTime(void)
> >  {
> > -     TimestampTz next_wakeup =3D 0;
> > +     TimestampTz next_wakeup;
> >
> >       /*
> > -      * Normal case: either there are no background workers at all, or=
 we're in
> > -      * a shutdown sequence (during which we ignore bgworkers altogeth=
er).
> > +      * If an ImmediateShutdown or a crash restart has set a SIGKILL t=
imeout,
> > +      * ignore everything else and wait for that.
> >        */
> > -     if (Shutdown > NoShutdown ||
> > -             (!StartWorkerNeeded && !HaveCrashedWorker))
> > +     if (Shutdown >=3D ImmediateShutdown || FatalError)
> >       {
> >               if (AbortStartTime !=3D 0)
> >               {
> > @@ -1582,14 +1584,16 @@ DetermineSleepTime(void)
> >
> >                       return seconds * 1000;
> >               }
> > -             else
> > -                     return 60 * 1000;
> >       }
> >
> > -     if (StartWorkerNeeded)
> > +     /* Time of next maybe_start_io_workers() call, or 0 for none. */
> > +     next_wakeup =3D maybe_start_io_workers_scheduled_at();
> > +
> > +     /* Ignore bgworkers during shutdown. */
> > +     if (StartWorkerNeeded && Shutdown =3D=3D NoShutdown)
> >               return 0;
>
> Why is the maybe_start_io_workers_scheduled_at() thing before the return =
0
> here?

Seems OK?  I mean sure I would to make this whole function more
uniform in structure, see my second patch, but...

> > -     if (HaveCrashedWorker)
> > +     if (HaveCrashedWorker && Shutdown =3D=3D NoShutdown)
> >       {
> >               dlist_mutable_iter iter;
> >
>
>
> > @@ -3797,6 +3811,15 @@ process_pm_pmsignal(void)
> >               StartWorkerNeeded =3D true;
> >       }
> >
> > +     /* Process IO worker start requests. */
> > +     if (CheckPostmasterSignal(PMSIGNAL_IO_WORKER_GROW))
> > +     {
> > +             /*
> > +              * No local flag, as the state is exposed through pgaio_w=
orker_*()
> > +              * functions.  This signal is received on potentially act=
ionable level
> > +              * changes, so that maybe_start_io_workers() will run.
> > +              */
> > +     }
> >       /* Process background worker state changes. */
> >       if (CheckPostmasterSignal(PMSIGNAL_BACKGROUND_WORKER_CHANGE))
> >       {
>
> Absolute nitpick - the different blocks so far have been separated by an =
empty
> line.

Fixed.

> > +     /* Only proceed if a "grow" request is pending from existing work=
ers. */
> > +     if (!pgaio_worker_test_grow())
> > +             return 0;
>
> So this accesses shared memory from postmaster.  I think this amount of a=
ccess
> is safe enough that that's ok. You'd have to somehow have corrupted
> postmaster's copy of io_worker_control, or unmapped the shared memory it =
is
> pointed to, for that to cause a crash.  The first shouldn't be an issue, =
the
> latter would be quite the confusion fo the state machine.

Cool.

> > +/*
> > + * Start I/O workers if required.  Used at startup, to respond to chan=
ge of
> > + * the io_min_workers GUC, when asked to start a new one due to submis=
sion
> > + * queue backlog, and after workers terminate in response to errors (b=
y
> > + * starting "replacement" workers).
> > + */
> > +static void
> > +maybe_start_io_workers(void)
> > +{
> > +     TimestampTz scheduled_at;
> >
> > -     /* Not enough running? */
> > -     while (io_worker_count < io_workers)
> > +     while ((scheduled_at =3D maybe_start_io_workers_scheduled_at()) !=
=3D 0)
> >       {
> > +             TimestampTz now =3D GetCurrentTimestamp();
> >               PMChild    *child;
> >               int                     i;
> >
> > +             Assert(pmState < PM_WAIT_IO_WORKERS);
> > +
> > +             /* Still waiting for the scheduled time? */
> > +             if (scheduled_at > now)
> > +                     break;
> > +
> > +             /* Clear the grow request flag if it is set. */
> > +             pgaio_worker_clear_grow();
> > +
> > +             /*
> > +              * Compute next launch time relative to the previous valu=
e, so that
> > +              * time spent on the postmaster's other duties don't resu=
lt in an
> > +              * inaccurate launch interval.
> > +              */
> > +             io_worker_launch_next_time =3D
> > +                     TimestampTzPlusMilliseconds(io_worker_launch_next=
_time,
> > +                                                                      =
       io_worker_launch_interval);
> > +
> > +             /*
> > +              * If that's already in the past, the interval is either =
impossibly
> > +              * short or we received no requests for new workers for a=
 period.
> > +              * Compute a new future time relative to the last launch =
time instead.
> > +              */
> > +             if (io_worker_launch_next_time <=3D now)
> > +                     io_worker_launch_next_time =3D
> > +                             TimestampTzPlusMilliseconds(io_worker_lau=
nch_last_time,
> > +                                                                      =
               io_worker_launch_interval);
>
> Did you intend to use TimestampTzPlusMilliseconds(now, ...) here?  Or did=
 you
> want to have this if after the next line:
>
> > +             io_worker_launch_last_time =3D now;
> > +
>
> Because otherwise I don't understand how this is intended to work.

I can't remember why I did it like that.  Changed.

> >               /* find unused entry in io_worker_children array */
> >               for (i =3D 0; i < MAX_IO_WORKERS; ++i)
> >               {
> > @@ -4454,20 +4539,14 @@ maybe_adjust_io_workers(void)
> >                       ++io_worker_count;
> >               }
> >               else
> > -                     break;                          /* try again next=
 time */
> > -     }
> > -
> > -     /* Too many running? */
> > -     if (io_worker_count > io_workers)
> > -     {
> > -             /* ask the IO worker in the highest slot to exit */
> > -             for (int i =3D MAX_IO_WORKERS - 1; i >=3D 0; --i)
> >               {
> > -                     if (io_worker_children[i] !=3D NULL)
> > -                     {
> > -                             kill(io_worker_children[i]->pid, SIGUSR2)=
;
> > -                             break;
> > -                     }
> > +                     /*
> > +                      * Fork failure: we'll try again after the launch=
 interval
> > +                      * expires, or be called again without delay if w=
e don't yet have
> > +                      * io_min_workers.  Don't loop here though, the p=
ostmaster has
> > +                      * other duties.
> > +                      */
> > +                     break;
> >               }
> >       }
> >  }
>
> Reading just this part of the diff I am wondering what is reponsible for
> reducing the number of workers below the max after a config change.  I as=
sume
> it's done in the workers, but it might be worth putting a comment here no=
ting
> that.

Done.

> > +/* Debugging support: show current IO and wakeups:ios statistics in ps=
. */
> > +/* #define PGAIO_WORKER_SHOW_PS_INFO */
> >
> >  typedef struct PgAioWorkerSubmissionQueue
> >  {
> > @@ -63,13 +67,34 @@ typedef struct PgAioWorkerSubmissionQueue
> >
> >  typedef struct PgAioWorkerSlot
> >  {
> > -     Latch      *latch;
> > -     bool            in_use;
> > +     ProcNumber      proc_number;
> >  } PgAioWorkerSlot;
> >
> > +/*
> > + * Sets of worker IDs are held in a simple bitmap, accessed through fu=
nctions
> > + * that provide a more readable abstraction.  If we wanted to support =
more
> > + * workers than that, the contention on the single queue would surely =
get too
> > + * high, so we might want to consider multiple pools instead of wideni=
ng this.
> > + */
> > +typedef uint64 PgAioWorkerSet;
>
> > +#define PGAIO_WORKER_SET_BITS (sizeof(PgAioWorkerSet) * CHAR_BIT)
> > +
> > +static_assert(PGAIO_WORKER_SET_BITS >=3D MAX_IO_WORKERS, "too small");
> > +
> >  typedef struct PgAioWorkerControl
> >  {
> > -     uint64          idle_worker_mask;
> > +     /* Seen by postmaster */
> > +     volatile bool grow;
>
> What's that volatile intending to do here? It avoids the needs for some
> compiler barriers, but it's not clear to me those would be needed here an=
yway.
> And it doesn't imply memory ordering, which I'm not sure is entirely wise
> here.  I'd probably just plop a full memory barrier in the few relevant
> places, easier to reason about that way, and it can't matter given the
> infrequency of access.  I'd say we should just use a proper atomic, but r=
ight
> now I don't think we do that in postmaster.

Changed to full memory barrier.

> > +     /* Protected by AioWorkerSubmissionQueueLock. */
> > +     PgAioWorkerSet idle_worker_set;
> > +
> > +     /* Protected by AioWorkerControlLock. */
> > +     PgAioWorkerSet worker_set;
> > +     int                     nworkers;
> > +
> > +     /* Protected by AioWorkerControlLock. */
> >       PgAioWorkerSlot workers[FLEXIBLE_ARRAY_MEMBER];
> >  } PgAioWorkerControl;
> >
> > @@ -91,15 +116,103 @@ const IoMethodOps pgaio_worker_ops =3D {
> >
> >
> > +static bool
> > +pgaio_worker_set_is_empty(PgAioWorkerSet *set)
> > +{
> > +     return *set =3D=3D 0;
> > +}
> > +
> > +static PgAioWorkerSet
> > +pgaio_worker_set_singleton(int worker)
> > +{
> > +     return UINT64_C(1) << worker;
> > +}
>
> I guess an assert about `worker` being small enough wouldn't hurt.

Done.

> > +static void
> > +pgaio_worker_set_fill(PgAioWorkerSet *set)
> > +{
> > +     *set =3D UINT64_MAX >> (PGAIO_WORKER_SET_BITS - MAX_IO_WORKERS);
> > +}
>
> What does "_fill" really mean?  Just that all valid bits are set? Why wou=
ldn't
> it be _all() or _full()?

I guess I got that from sigset_t...  Trying pgaio_workerset_all().

> > +static int
> > +pgaio_worker_set_get_highest(PgAioWorkerSet *set)
> > +{
> > +     Assert(!pgaio_worker_set_is_empty(set));
> > +     return pg_leftmost_one_pos64(*set);
> > +}
>
> "worker_set_get*" reads quite awkwardly.  Maybe just going for
> pgaio_workerset_* would help?
>
> Or maybe just name it PgAioWset/pgaio_wset_ or such?

OK let's try "workerset".

> > +static void
> > +pgaio_worker_grow(bool grow)
> > +{
> > +     /*
> > +      * This is called from sites that don't hold AioWorkerControlLock=
, but
> > +      * these values change infrequently and an up-to-date value is no=
t
> > +      * required for this heuristic purpose.
> > +      */
>
> Is it actually useful to do this while not holding the control lock?  Ah,=
 I
> see, this is due to the split of submission and control lock.

Yeah actually that comment is just confusing.  Removed.  It's pretty
clear that this flag has the usual sort of postmaster request flag
semantics and tolerates a bit of fuzziness.

> > +     if (!grow)
> > +     {
> > +             /* Avoid dirtying memory if not already set. */
> > +             if (io_worker_control->grow)
> > +                     io_worker_control->grow =3D false;
>
> Hm. pgaio_worker_grow(grow=3Dfalse) is a bit odd.  And this is basically =
a copy
> of pgaio_worker_cancel_grow() - I realize that's intended for postmaster,=
 but
> somehow it's a bit odd.

Hmm, right.

> Maybe just name it pgaio_worker_set_grow()?

OK how about:

pgaio_worker_request_grow()
pgaio_worker_cancel_grow()


> > +/*
> > + * Called by the postmaster to check if a new worker is needed.
> > + */
> > +bool
> > +pgaio_worker_test_grow(void)
> > +{
> > +     return io_worker_control && io_worker_control->grow;
> > +}
> > +
> > +/*
> > + * Called by the postmaster to clear the grow flag.
> > + */
> > +void
> > +pgaio_worker_clear_grow(void)
> > +{
> > +     if (io_worker_control)
> > +             io_worker_control->grow =3D false;
> > +}
>
> Maybe we should add _pm_ in there to make it clearer that they're not for
> general use?

Done.

> > @@ -226,8 +413,7 @@ pgaio_worker_submit(uint16 num_staged_ios, PgAioHan=
dle **staged_ios)
> >  {
> >       PgAioHandle **synchronous_ios =3D NULL;
> >       int                     nsync =3D 0;
> > -     Latch      *wakeup =3D NULL;
> > -     int                     worker;
> > +     int                     worker =3D -1;
> >
> >       Assert(num_staged_ios <=3D PGAIO_SUBMIT_BATCH_SIZE);
> >
> > @@ -252,19 +438,15 @@ pgaio_worker_submit(uint16 num_staged_ios, PgAioH=
andle **staged_ios)
> >                               break;
> >                       }
> >
> > -                     if (wakeup =3D=3D NULL)
> > -                     {
> > -                             /* Choose an idle worker to wake up if we=
 haven't already. */
> > -                             worker =3D pgaio_worker_choose_idle();
> > -                             if (worker >=3D 0)
> > -                                     wakeup =3D io_worker_control->wor=
kers[worker].latch;
> > -
> > -                             pgaio_debug_io(DEBUG4, staged_ios[i],
> > -                                                        "choosing work=
er %d",
> > -                                                        worker);
> > -                     }
> > +                     /* Choose one worker to wake for this batch. */
> > +                     if (worker =3D=3D -1)
> > +                             worker =3D pgaio_worker_choose_idle(0);
> >               }
>
> If we only want to do this once per "batch", why not just do it outside t=
he
> num_staged_ios loop?

Two steps: pgaio_worker_choose_idle() must be done while holding the
queue lock (will probably finish up revising this in future work on
removing locks...).  pgaio_worker_wake() is called outside the loop,
after releasing the lock.

> > @@ -295,14 +474,27 @@ pgaio_worker_submit(uint16 num_staged_ios, PgAioH=
andle **staged_ios)
> >  static void
> >  pgaio_worker_die(int code, Datum arg)
> >  {
> > -     LWLockAcquire(AioWorkerSubmissionQueueLock, LW_EXCLUSIVE);
> > -     Assert(io_worker_control->workers[MyIoWorkerId].in_use);
> > -     Assert(io_worker_control->workers[MyIoWorkerId].latch =3D=3D MyLa=
tch);
> > +     PgAioWorkerSet notify_set;
> >
> > -     io_worker_control->idle_worker_mask &=3D ~(UINT64_C(1) << MyIoWor=
kerId);
> > -     io_worker_control->workers[MyIoWorkerId].in_use =3D false;
> > -     io_worker_control->workers[MyIoWorkerId].latch =3D NULL;
> > +     LWLockAcquire(AioWorkerSubmissionQueueLock, LW_EXCLUSIVE);
> > +     pgaio_worker_set_remove(&io_worker_control->idle_worker_set, MyIo=
WorkerId);
> >       LWLockRelease(AioWorkerSubmissionQueueLock);
> > +
> > +     LWLockAcquire(AioWorkerControlLock, LW_EXCLUSIVE);
> > +     Assert(io_worker_control->workers[MyIoWorkerId].proc_number =3D=
=3D MyProcNumber);
> > +     io_worker_control->workers[MyIoWorkerId].proc_number =3D INVALID_=
PROC_NUMBER;
> > +     Assert(pgaio_worker_set_contains(&io_worker_control->worker_set, =
MyIoWorkerId));
> > +     pgaio_worker_set_remove(&io_worker_control->worker_set, MyIoWorke=
rId);
> > +     notify_set =3D io_worker_control->worker_set;
> > +     Assert(io_worker_control->nworkers > 0);
> > +     io_worker_control->nworkers--;
> > +     Assert(pgaio_worker_set_count(&io_worker_control->worker_set) =3D=
=3D
> > +                io_worker_control->nworkers);
> > +     LWLockRelease(AioWorkerControlLock);
> > +
> > +     /* Notify other workers on pool change. */
>
> Why are we notifying them on pool changes?

Comments added to explain.  It closes a wakeup-loss race (imagine if
you consumed a wakeup while you were exiting due to timeout; noone
else would wake up, which I fixed with this big hammer).

> > +     while (!pgaio_worker_set_is_empty(&notify_set))
> > +             pgaio_worker_wake(pgaio_worker_set_pop_lowest(&notify_set=
));
>
> I did already wonder further up if pgaio_worker_wake() should just receiv=
e a
> worker_set as an argument.

I have added pgaio_workerset_wake().

> > @@ -312,33 +504,34 @@ pgaio_worker_die(int code, Datum arg)
> >  static void
> >  pgaio_worker_register(void)
> >  {
> > +     PgAioWorkerSet free_worker_set;
> > +     PgAioWorkerSet old_worker_set;
> > +
> >       MyIoWorkerId =3D -1;
> >
> > -     /*
> > -      * XXX: This could do with more fine-grained locking. But it's al=
so not
> > -      * very common for the number of workers to change at the moment.=
..
> > -      */
> > -     LWLockAcquire(AioWorkerSubmissionQueueLock, LW_EXCLUSIVE);
> > +     LWLockAcquire(AioWorkerControlLock, LW_EXCLUSIVE);
>
> I guess it could be useful to assert that nworkers is small enough before
> doing anything.

OK.

> > +     pgaio_worker_set_fill(&free_worker_set);
> > +     pgaio_worker_set_subtract(&free_worker_set, &io_worker_control->w=
orker_set);
> > +     if (!pgaio_worker_set_is_empty(&free_worker_set))
> > +             MyIoWorkerId =3D pgaio_worker_set_get_lowest(&free_worker=
_set);
> > +     if (MyIoWorkerId =3D=3D -1)
> > +             elog(ERROR, "couldn't find a free worker ID");
>
> I'd probably add a comment saying "/* find lowest unused worker ID */" or
> such, that was more immediately obvious in the old code.

Done.

> > +/*
> > + * Check if this backend is allowed to time out, and thus should use a
> > + * non-infinite sleep time.  Only the highest-numbered worker is allow=
ed to
> > + * time out, and only if the pool is above io_min_workers.  Serializin=
g
> > + * timeouts keeps IDs in a range 0..N without gaps, and avoids undersh=
ooting
> > + * io_min_workers.
>
> But it's ok if a lower numbered worker errors out, right?  There will be =
a
> temporary gap, but we will start a new worker for it?

Yes it is OK for there to be gaps.

If any worker errors out, it will be replaced when reaped if we fell
below io_min_workers, and otherwise replaced via the usual means, ie
once the backlog detection and the launch delay allow it.  I did have
a version that always replaced *every* worker with exit code 1
immediately, but I started wondering if we really want persistent
errors to turn into high speed fork() loops.  I'm still not sure TBH.
We don't expect workers to error out, so it means something is already
pretty screwed up and you might appreciate the rate limiting?

I have an always-replace patch somewhere, as I've vacillated on that
point a couple of times.  I will post a separate fixup for
consideration.

> Does that happen even
> if there's a shrink of the set of required workers at the same time as a =
lower
> numbered worker errors out?

If a workers errors out (exit code 1) and an idle worker timed out
(exit code 0), then it's no different: if the new count dropped below
io_min_workers, we start a worker immediate after reaping the process.
Othewise we let the normal algorithm decide to start a new worker
if/when required.

> > @@ -439,10 +666,9 @@ IoWorkerMain(const void *startup_data, size_t star=
tup_data_len)
> >       while (!ShutdownRequestPending)
> >       {
> >               uint32          io_index;
> > -             Latch      *latches[IO_WORKER_WAKEUP_FANOUT];
> > -             int                     nlatches =3D 0;
> > -             int                     nwakeups =3D 0;
> > -             int                     worker;
> > +             int                     worker =3D -1;
> > +             int                     queue_depth =3D 0;
> > +             bool            grow =3D false;
> >
> >               /*
> >                * Try to get a job to do.
> > @@ -453,38 +679,64 @@ IoWorkerMain(const void *startup_data, size_t sta=
rtup_data_len)
> >               LWLockAcquire(AioWorkerSubmissionQueueLock, LW_EXCLUSIVE)=
;
> >               if ((io_index =3D pgaio_worker_submission_queue_consume()=
) =3D=3D -1)
> >               {
> > -                     /*
> > -                      * Nothing to do.  Mark self idle.
> > -                      *
> > -                      * XXX: Invent some kind of back pressure to redu=
ce useless
> > -                      * wakeups?
> > -                      */
> > -                     io_worker_control->idle_worker_mask |=3D (UINT64_=
C(1) << MyIoWorkerId);
> > +                     /* Nothing to do.  Mark self idle. */
> > +                     pgaio_worker_set_insert(&io_worker_control->idle_=
worker_set,
> > +                                                                     M=
yIoWorkerId);
> >               }
> >               else
> >               {
> >                       /* Got one.  Clear idle flag. */
> > -                     io_worker_control->idle_worker_mask &=3D ~(UINT64=
_C(1) << MyIoWorkerId);
> > +                     pgaio_worker_set_remove(&io_worker_control->idle_=
worker_set,
> > +                                                                     M=
yIoWorkerId);
>
> Wonder if we should keep track of whether we marked ourselves idle to avo=
id
> needing to do that.  But that would be a separate optimization really.

Fair point.  OK.

> > +                     /*
> > +                      * See if we should wake up a higher numbered pee=
r.  Only do that
> > +                      * if this worker is not receiving spurious wakeu=
ps itself.
>
> The "not receiving spurious wakeups" condition is wakeups < ios?

Yes, see new comment near PGAIO_WORKER_WAKEUP_RATIO_SATURATE.

> I think both 'wakeups" and "ios" are a bit too generically named. Based o=
n the
> names I have no idea what this heuristic might be.

I have struggled to name them.  Does wakeup_count and io_count help?

> > +                      * This heuristic tries to discover the useful wa=
keup propagation
> > +                      * chain length when IOs are very fast and worker=
s wake up to find
> > +                      * that all IOs have already been taken.
> > +                      *
> > +                      * If we chose not to wake a worker when we ideal=
ly should have,
> > +                      * the ratio will soon be corrected.
> > +                      */
> > +                     if (wakeups <=3D ios)
> >                       {
> > +                             queue_depth =3D pgaio_worker_submission_q=
ueue_depth();
> > +                             if (queue_depth > 0)
> > +                             {
> > +                                     worker =3D pgaio_worker_choose_id=
le(MyIoWorkerId + 1);
>
> Is it a problem that we are passing an ID that's potentially bigger than =
the
> biggest legal worker ID?  It's probably fine as long as MAX_WORKERS is 32=
 and
> the bitmap is a 64bit integer, but ...

Oof.  Fixed.

> > +                                     /*
> > +                                      * If there were no idle higher n=
umbered peers and there
> > +                                      * are more than enough IOs queue=
d for me and all lower
> > +                                      * numbered peers, then try to st=
art a new worker.
> > +                                      */
> > +                                     if (worker =3D=3D -1 && queue_dep=
th > MyIoWorkerId)
> > +                                             grow =3D true;
> > +                             }
>
> We probably shouldn't request growth when already at the cap? That could
> generate a *lot* of pmsignal traffic, I think?

No, we only set it if it isn't already set (like a latch), and only
send a pmsignal when we set it (like a latch), and the postmaster only
clears it if it can start a worker (unlike a latch).  That applies in
general, not just when we hit the cap of io_max_workers: while the
postmaster is waiting for launch interval to expire, it will leave the
flag set, suppressed for 100ms or whatever, and the in the special
case of io_max_workers, for as long as the count remains that high.

> I don't have an immediate intuitive understanding of why the submission q=
ueue
> depth is a good measure here.
>
> If there are 10 workers that are busy 100% of the time, and the submissio=
n
> queue is usually 6 deep with not-being-worked-on IOs, why do we not want =
to
> start more workers?
>
> It actually seems to work - but I don't actually understand why.

I should have made it clearer that that's a secondary condition.  The
primary condition is: a worker wanted to wake another worker, but
found that none were idle.  Unfortunately the whole system is a bit
too asynchronous for that to be a reliable cue on its own.  So, I also
check if the queue appears to be (1) obviously growing: that's clearly
too long and must be introducing latency, or (2) varying "too much".
Which I detect in exactly the same way.

Imagine a histogram that look like this:

LOG:  depth 00: 7898
LOG:  depth 01: 1630
LOG:  depth 02: 308
LOG:  depth 03: 93
LOG:  depth 04: 40
LOG:  depth 05: 19
LOG:  depth 06: 6
LOG:  depth 07: 4
LOG:  depth 08: 0
LOG:  depth 09: 1
LOG:  depth 10: 1
LOG:  depth 11: 0
LOG:  depth 12: 0
LOG:  depth 13: 0

If you're failing to find idle workers to wake up AND our managic
threshold is hit by something in that long tail, then it'll call for
backup.  Of course I'm totally sidestepping a lot of queueing theory
maths and just saying "I'd better be able to find an idle worker when
I want to" and if not, "there had better not be any outliers that
reach this far".

I've written a longer explanation in a long comment.  Including a
little challenge for someone to do better with real science and maths.
I hope it's a bit clearer at least.

> ninja install-test-files
> io_max_workers=3D32
> debug_io_direct=3Ddata
> effective_io_concurrency=3D16
> shared_buffers=3D5GB
>
> pgbench -i -q -s 100 --fillfactor=3D30
>
> CREATE EXTENSION IF NOT EXISTS test_aio;
> CREATE EXTENSION IF NOT EXISTS pg_buffercache;
> DROP TABLE IF EXISTS pattern_random_pgbench;
> CREATE TABLE pattern_random_pgbench AS SELECT ARRAY(SELECT random(0, pg_r=
elation_size('pgbench_accounts')/8192 - 1)::int4 FROM generate_series(1, pg=
_relation_size('pgbench_accounts')/8192)) AS pattern;
>
> My test is:
>
> SET effective_io_concurrency =3D 20;
> SELECT pg_buffercache_evict_relation('pgbench_accounts');
> SELECT read_stream_for_blocks('pgbench_accounts', pattern) FROM pattern_r=
andom_pgbench LIMIT 1;
>
>
> We end up with ~24-28 workers, even though we never have more than 20 IOs=
 in
> flight. Not entirely sure why. I guess it's just that after doing an IO t=
he
> worker needs to mark itself idle etc?

Yep.  It would be nice to make it a bit more accurate in later cycles.
It tends to overprovision rather than under, since it thinks all other
workers are busy.  That information is a bit racy.  In this version
I've made a small improvement: it uses nworkers directly, under the
big new comment, instead of an unnecessarily complicated
approximation.

> >               if (io_index !=3D -1)
> >               {
> >                       PgAioHandle *ioh =3D NULL;
> >
> > +                     /* Cancel timeout and update wakeup:work ratio. *=
/
> > +                     idle_timeout_abs =3D 0;
> > +                     if (++ios =3D=3D PGAIO_WORKER_STATS_MAX)
> > +                     {
> > +                             wakeups /=3D 2;
> > +                             ios /=3D 2;
> > +                     }
>
>
> /* Saturation for counters used to estimate wakeup:work ratio. */
> #define PGAIO_WORKER_STATS_MAX 4
>
> STATS_MAX sounds like it's just about some reporting or such.

I have renamed it to PGAIO_WORKER_RATIO_MAX and written a big comment
at the top to explain what it's for.io

> >                       ioh =3D &pgaio_ctl->io_handles[io_index];
> >                       error_ioh =3D ioh;
> >                       errcallback.arg =3D ioh;
> > @@ -537,6 +789,14 @@ IoWorkerMain(const void *startup_data, size_t star=
tup_data_len)
> >                       }
> >  #endif
> >
> > +#ifdef PGAIO_WORKER_SHOW_PS_INFO
> > +                     sprintf(cmd, "%d: [%s] %s",
> > +                                     MyIoWorkerId,
> > +                                     pgaio_io_get_op_name(ioh),
> > +                                     pgaio_io_get_target_description(i=
oh));
> > +                     set_ps_display(cmd);
> > +#endif
>
> Note that this leaks memory. See the target_description comment:
>
> /*
>  * Return a stringified description of the IO's target.
>  *
>  * The string is localized and allocated in the current memory context.
>  */

Fixed.

> >                       /*
> >                        * We don't expect this to ever fail with ERROR o=
r FATAL, no need
> >                        * to keep error_ioh set to the IO.
> > @@ -550,8 +810,75 @@ IoWorkerMain(const void *startup_data, size_t star=
tup_data_len)
> >               }
> >               else
> >               {
> > -                     WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_D=
EATH, -1,
> > -                                       WAIT_EVENT_IO_WORKER_MAIN);
> > +                     int                     timeout_ms;
> > +
> > +                     /* Cancel new worker request if pending. */
> > +                     pgaio_worker_grow(false);
>
> That seems to happen very frequently.

Yeah, but it doesn't write to memory after someone else does it.  This
again is part of the strategy for preventing excess workers from being
created.  If I've found the queue to be empty.

> > +                             /*
> > +                              * All workers maintain the absolute time=
out value, but only
> > +                              * the highest worker can actually time o=
ut and only if
> > +                              * io_min_workers is satisfied.  All othe=
rs wait only for
> > +                              * explicit wakeups caused by queue inser=
tion, wakeup
> > +                              * propagation, change of pool size (poss=
ibly promoting one to
> > +                              * new highest) or GUC reload.
> > +                              */
> > +                             if (pgaio_worker_can_timeout())
> > +                                     timeout_ms =3D
> > +                                             TimestampDifferenceMillis=
econds(now,
> > +                                                                      =
                                       idle_timeout_abs);
> > +                             else
> > +                                     timeout_ms =3D -1;
>
>
> Hm. This way you get very rapid worker pool reductions.  Configured
> io_worker_idle_timeout=3D1s, started a bunch of work of and observed the =
worker
> count after the work finishes:
>
> Mon 06 Apr 2026 02:08:28 PM EDT (every 1s)
>
> count
> 32
> (1 row)
> Mon 06 Apr 2026 02:08:29 PM EDT (every 1s)
>
> count
> 32
> (1 row)
> Mon 06 Apr 2026 02:08:30 PM EDT (every 1s)
>
> count
> 1
> (1 row)
> Mon 06 Apr 2026 02:08:31 PM EDT (every 1s)
>
> count
> 1
> (1 row)
>
>
> Of course this is a ridiculuously low setting, but it does seems like sta=
rting
> the timeout even when not the highest numbered worker will lead to a lot =
of
> quick yoyoing.

I have changed it so that after one worker times out, the next one
begins its timeout count from 0.  (This is one of the reasons for that
"notify the whole pool when I exit" thing.)

--0000000000009e581e064edc682e
Content-Type: text/x-patch; charset="US-ASCII";
	name="v5-0001-aio-Adjust-I-O-worker-pool-size-automatically.patch"
Content-Disposition: attachment;
	filename="v5-0001-aio-Adjust-I-O-worker-pool-size-automatically.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_mnohkym00>
X-Attachment-Id: f_mnohkym00
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--0000000000009e581e064edc682e--