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>
 <CAAKRu_YWNKs2=mE27C1W8VxPJa1UR+YVuckw5kYzWowTStCHiQ@mail.gmail.com>
 <CAD21AoAB-jtKvYd-QbnhbanoY+-PDCXvrX-JhBUqGFrB6e7eTw@mail.gmail.com>
 <CAAKRu_Zir77=EAQxytN4Bc-P-==1YLC9KiK=kqPricjVzac8ng@mail.gmail.com>
 <CAD21AoCBqrzCqXPGjhVHJwJThYW_CmBOpWL2J_6Bb_4qMwcsuw@mail.gmail.com> <CAAKRu_YxDh-31zzF9vA=6FfggE8-mQo8bwxCxaFqY=pb8kTTag@mail.gmail.com>
In-Reply-To: <CAAKRu_YxDh-31zzF9vA=6FfggE8-mQo8bwxCxaFqY=pb8kTTag@mail.gmail.com>
From: Melanie Plageman <melanieplageman@gmail.com>
Date: Fri, 10 Mar 2023 19:34:44 -0500
Message-ID: <CAAKRu_Y0xdDu-6rKEJk8APJTupdOobjoNtGVKLsfyFYcQEMKZw@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="000000000000035a5a05f6950c4d"
Archived-At: <https://www.postgresql.org/message-id/CAAKRu_Y0xdDu-6rKEJk8APJTupdOobjoNtGVKLsfyFYcQEMKZw%40mail.gmail.com>
Precedence: bulk

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

On Fri, Mar 10, 2023 at 6:11=E2=80=AFPM Melanie Plageman
<melanieplageman@gmail.com> wrote:
>
> Quotes below are combined from two of Sawada-san's emails.
>
> I've also attached a patch with my suggested current version.
>
> On Thu, Mar 9, 2023 at 10:27=E2=80=AFPM Masahiko Sawada <sawada.mshk@gmai=
l.com> wrote:
> >
> > On Fri, Mar 10, 2023 at 11:23=E2=80=AFAM Melanie Plageman
> > <melanieplageman@gmail.com> wrote:
> > >
> > > On Tue, Mar 7, 2023 at 12:10=E2=80=AFAM Masahiko Sawada <sawada.mshk@=
gmail.com> wrote:
> > > >
> > > > On Mon, Mar 6, 2023 at 5:26=E2=80=AFAM Melanie Plageman
> > > > <melanieplageman@gmail.com> wrote:
> > > > >
> > > > > On Thu, Mar 2, 2023 at 6:37=E2=80=AFPM Melanie Plageman
> > > > > In this version I've removed wi_cost_delay from WorkerInfoData. T=
here 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_dela=
y is
> > > > > that we have to have a way to keep track of whether or not autova=
cuum
> > > > > 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 a=
re in
> > > > > use and the other to store the value of the table option cost del=
ay. I
> > > > > didn't want to use a single variable with a special value to indi=
cate
> > > > > 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.
> > > >
> > > > While it's true that wi_cost_delay doesn't need to be shared, it se=
ems
> > > > to make the logic somewhat complex. We need to handle cost_delay in=
 a
> > > > different way from other vacuum-related parameters and we need to m=
ake
> > > > sure av[_use]_table_option_cost_delay are set properly. Removing
> > > > wi_cost_delay from WorkerInfoData saves 8 bytes shared memory per
> > > > autovacuum worker but it might be worth considering to keep
> > > > wi_cost_delay for simplicity.
> > >
> > > Ah, it turns out we can't really remove wi_cost_delay from WorkerInfo
> > > anyway because the launcher doesn't know anything about table options
> > > and so the workers have to keep an updated wi_cost_delay that the
> > > launcher or other autovac workers who are not vacuuming that table ca=
n
> > > read from when calculating the new limit in autovac_balance_cost().
> >
> > IIUC if any of the cost delay parameters has been set individually,
> > the autovacuum worker is excluded from the balance algorithm.
>
> Ah, yes! That's right. So it is not a problem. Then I still think
> removing wi_cost_delay from the worker info makes sense. wi_cost_delay
> is a double and can't easily be accessed atomically the way
> wi_cost_limit can be.
>
> Keeping the cost delay local to the backends also makes it clear that
> cost delay is not something that should be written to by other backends
> or that can differ from worker to worker. Without table options in the
> picture, the cost delay should be the same for any worker who has
> reloaded the config file.
>
> As for the cost limit safe access issue, maybe we can avoid a LWLock
> acquisition for reading wi_cost_limit by using an atomic similar to what
> you suggested here for "did_rebalance".
>
> > > 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 n=
ew
> > > worker is launched and by workers between vacuuming tables). Maybe we
> > > can read from it less frequently?
> >
> > Yeah, acquiring the lwlock for every call to vacuum_delay_point()
> > seems to be harmful. One idea would be to have one sig_atomic_t
> > variable in WorkerInfoData and autovac_balance_cost() set it to true
> > after rebalancing the worker's cost-limit. The worker can check it
> > without locking and update its delay parameters if the flag is true.
>
> Instead of having the atomic indicate whether or not someone (launcher
> or another worker) did a rebalance, it would simply store the current
> cost limit. Then the worker can normally access it with a simple read.
>
> My rationale is that if we used an atomic to indicate whether or not we
> did a rebalance ("did_rebalance"), we would have the same cache
> coherency guarantees as if we just used the atomic for the cost limit.
> If we read from the "did_rebalance" variable and missed someone having
> written to it on another core, we still wouldn't get around to checking
> the wi_cost_limit variable in shared memory, so it doesn't matter that
> we bothered to keep it in shared memory and use a lock to access it.
>
> I noticed we don't allow wi_cost_limit to ever be less than 0, so we
> could store wi_cost_limit in an atomic uint32.
>
> I'm not sure if it is okay to do pg_atomic_read_u32() and
> pg_atomic_unlocked_write_u32() or if we need pg_atomic_write_u32() in
> most cases.
>
> I've implemented the atomic cost limit in the attached patch. Though,
> I'm pretty unsure about how I initialized the atomics in
> AutoVacuumShmemInit()...
>
> If the consensus is that it is simply too confusing to take
> wi_cost_delay out of WorkerInfo, we might be able to afford using a
> shared lock to access it because we won't call AutoVacuumUpdateDelay()
> on every invocation of vacuum_delay_point() -- only when we've reloaded
> the config file.

One such implementation is attached.

- Melanie

--000000000000035a5a05f6950c4d
Content-Type: text/x-patch; charset="US-ASCII"; 
	name="v4-0001-vacuum-reloads-config-file-more-often.patch"
Content-Disposition: attachment; 
	filename="v4-0001-vacuum-reloads-config-file-more-often.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_lf38i45l0>
X-Attachment-Id: f_lf38i45l0
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--000000000000035a5a05f6950c4d--