MIME-Version: 1.0
References: <CAAKRu_ZngzqnEODc7LmS1NH04Kt6Y9huSjz5pp7+DXhrjDA0gw@mail.gmail.com>
 <CAD21AoC=b09pzWNyPYuti0M2DQwy57CGF9UWWb_+v=gdWeNG=A@mail.gmail.com>
 <CAAKRu_bR2VrTUskR24GkXV15SxPaCiHYD=soOuWZcT-rGDcA8Q@mail.gmail.com>
 <CAD21AoB=EC6wzjjqDXKmNEhu_BhGg0g_Gc50yh_zvXqiDC_OSg@mail.gmail.com> <CAAKRu_buP5wzsho3qNw5o9_R0pF69FRM5hgCmr-mvXmGXwdA7A@mail.gmail.com>
In-Reply-To: <CAAKRu_buP5wzsho3qNw5o9_R0pF69FRM5hgCmr-mvXmGXwdA7A@mail.gmail.com>
From: Melanie Plageman <melanieplageman@gmail.com>
Date: Sun, 5 Mar 2023 15:26:12 -0500
Message-ID: <CAAKRu_YWNKs2=mE27C1W8VxPJa1UR+YVuckw5kYzWowTStCHiQ@mail.gmail.com>
Subject: Re: Should vacuum process config file reload more often
To: Masahiko Sawada <sawada.mshk@gmail.com>
Cc: Pg Hackers <pgsql-hackers@postgresql.org>, Andres Freund <andres@anarazel.de>, 
	Amit Kapila <amit.kapila16@gmail.com>
Content-Type: multipart/mixed; boundary="000000000000f9efda05f62cfddd"
Archived-At: <https://www.postgresql.org/message-id/CAAKRu_YWNKs2%3DmE27C1W8VxPJa1UR%2BYVuckw5kYzWowTStCHiQ%40mail.gmail.com>
Precedence: bulk

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

On Thu, Mar 2, 2023 at 6:37=E2=80=AFPM Melanie Plageman
<melanieplageman@gmail.com> wrote:
>
> On Thu, Mar 2, 2023 at 2:36=E2=80=AFAM Masahiko Sawada <sawada.mshk@gmail=
.com> wrote:
> >
> > On Thu, Mar 2, 2023 at 10:41 AM Melanie Plageman
> > <melanieplageman@gmail.com> wrote:
> > > On another topic, I've just realized that when autovacuuming we only
> > > update tab->at_vacuum_cost_delay/limit from
> > > autovacuum_vacuum_cost_delay/limit for each table (in
> > > table_recheck_autovac()) and then use that to update
> > > MyWorkerInfo->wi_cost_delay/limit. MyWorkerInfo->wi_cost_delay/limit =
is
> > > what is used to update VacuumCostDelay/Limit in AutoVacuumUpdateDelay=
().
> > > So, even if we reload the config file in vacuum_delay_point(), if we
> > > don't use the new value of autovacuum_vacuum_cost_delay/limit it will
> > > have no effect for autovacuum.
> >
> > Right, but IIUC wi_cost_limit (and VacuumCostDelayLimit) might be
> > updated. After the autovacuum launcher reloads the config file, it
> > calls autovac_balance_cost() that updates that value of active
> > workers. I'm not sure why we don't update workers' wi_cost_delay,
> > though.
>
> Ah yes, I didn't realize this. Thanks. I went back and did more code
> reading/analysis, and I see no reason why we shouldn't update
> worker->wi_cost_delay to the new value of autovacuum_vac_cost_delay in
> autovac_balance_cost(). Then, as you said, the autovac launcher will
> call autovac_balance_cost() when it reloads the configuration file.
> Then, the next time the autovac worker calls AutoVacuumUpdateDelay(), it
> will update VacuumCostDelay.
>
> > > I started writing a little helper that could be used to update these
> > > workerinfo->wi_cost_delay/limit in vacuum_delay_point(),
> >
> > Since we set vacuum delay parameters for autovacuum workers so that we
> > ration out I/O equally, I think we should keep the current mechanism
> > that the autovacuum launcher sets workers' delay parameters and they
> > update accordingly.
>
> Yes, agreed, it should go in the same place as where we update
> wi_cost_limit (autovac_balance_cost()). I think we should potentially
> rename autovac_balance_cost() because its name and all its comments
> point to its only purpose being to balance the total of the workers
> wi_cost_limits to no more than autovacuum_vacuum_cost_limit. And the
> autovacuum_vacuum_cost_delay doesn't need to be balanced in this way.
>
> Though, since this change on its own would make autovacuum pick up new
> values of autovacuum_vacuum_cost_limit (without having the worker reload
> the config file), I wonder if it makes sense to try and have
> vacuum_delay_point() only reload the config file if it is an explicit
> vacuum or an analyze not being run in an outer transaction (to avoid
> overhead of reloading config file)?
>
> The lifecycle of this different vacuum delay-related gucs and how it
> differs between autovacuum workers and explicit vacuum is quite tangled
> already, though.

So, I've attached a new version of the patch which is quite different
from the previous versions.

In this version I've removed wi_cost_delay from WorkerInfoData. There is
no synchronization of cost_delay amongst workers, so there is no reason
to keep it in shared memory.

One consequence of not updating VacuumCostDelay from wi_cost_delay is
that we have to have a way to keep track of whether or not autovacuum
table options are in use.

This patch does this in a cringeworthy way. I added two global
variables, one to track whether or not cost delay table options are in
use and the other to store the value of the table option cost delay. I
didn't want to use a single variable with a special value to indicate
that table option cost delay is in use because
autovacuum_vacuum_cost_delay already has special values that mean
certain things. My code needs a better solution.

It is worth mentioning that I think that in master,
AutoVacuumUpdateDelay() was incorrectly reading wi_cost_limit and
wi_cost_delay from shared memory without holding a lock.

I've added in a shared lock for reading from wi_cost_limit in this
patch. However, AutoVacuumUpdateLimit() is called unconditionally in
vacuum_delay_point(), which is called quite often (per block-ish), so I
was trying to think if there is a way we could avoid having to check
this shared memory variable on every call to vacuum_delay_point().
Rebalances shouldn't happen very often (done by the launcher when a new
worker is launched and by workers between vacuuming tables). Maybe we
can read from it less frequently?

Also not sure how the patch interacts with failsafe autovac and parallel
vacuum.

- Melanie

--000000000000f9efda05f62cfddd
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v2-0001-Reload-config-file-more-often-while-vacuuming.patch"
Content-Disposition: attachment; 
	filename="v2-0001-Reload-config-file-more-often-while-vacuuming.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_levu0eh30>
X-Attachment-Id: f_levu0eh30
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--000000000000f9efda05f62cfddd--