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> <CAD21AoC=BRMwUpVDf1tzDa13--dLhuq=c2XQ_KAYA4Qx3cS=kA@mail.gmail.com>
In-Reply-To: <CAD21AoC=BRMwUpVDf1tzDa13--dLhuq=c2XQ_KAYA4Qx3cS=kA@mail.gmail.com>
From: Melanie Plageman <melanieplageman@gmail.com>
Date: Sat, 18 Mar 2023 18:47:07 -0400
Message-ID: <CAAKRu_Z4NdHk6EofruFzrasO10bzQYCNuvZ=Rri1wJ6vwoV4-g@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="000000000000e9c22005f7347914"
Archived-At: <https://www.postgresql.org/message-id/CAAKRu_Z4NdHk6EofruFzrasO10bzQYCNuvZ%3DRri1wJ6vwoV4-g%40mail.gmail.com>
Precedence: bulk

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

On Wed, Mar 15, 2023 at 1:14=E2=80=AFAM Masahiko Sawada <sawada.mshk@gmail.=
com> wrote:
> On Sat, Mar 11, 2023 at 8:11=E2=80=AFAM Melanie Plageman
> <melanieplageman@gmail.com> wrote:
> > I've implemented the atomic cost limit in the attached patch. Though,
> > I'm pretty unsure about how I initialized the atomics in
> > AutoVacuumShmemInit()...
>
> +
>                  /* initialize the WorkerInfo free list */
>                  for (i =3D 0; i < autovacuum_max_workers; i++)
>                          dlist_push_head(&AutoVacuumShmem->av_freeWorkers=
,
>                                                          &worker[i].wi_li=
nks);
> +
> +                dlist_foreach(iter, &AutoVacuumShmem->av_freeWorkers)
> +                        pg_atomic_init_u32(
> +
> &(dlist_container(WorkerInfoData, wi_links, iter.cur))->wi_cost_limit,
> +                                                           0);
> +
>
> I think we can do like:
>
>     /* initialize the WorkerInfo free list */
>     for (i =3D 0; i < autovacuum_max_workers; i++)
>     {
>         dlist_push_head(&AutoVacuumShmem->av_freeWorkers,
>                                         &worker[i].wi_links);
>         pg_atomic_init_u32(&(worker[i].wi_cost_limit));
>     }

Ah, yes, I was distracted by the variable name "worker" (as opposed to
"workers").

> > 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 potential option to avoid taking a shared lock on every call to
> > AutoVacuumUpdateDelay() is to set a global variable to indicate that we
> > did update it (since we are the only ones updating it) and then only
> > take the shared LWLock in AutoVacuumUpdateDelay() if that flag is true.
> >
>
> If we remove wi_cost_delay from WorkerInfo, probably we don't need to
> acquire the lwlock in AutoVacuumUpdateDelay()? The shared field we
> access in that function will be only wi_dobalance, but this field is
> updated only by its owner autovacuum worker.

I realized that we cannot use dobalance to decide whether or not to
update wi_cost_delay because dobalance could be false because of table
option cost limit being set (with no table option cost delay) and we
would still need to update VacuumCostDelay and wi_cost_delay with the
new value of autovacuum_vacuum_cost_delay.

But v5 skirts around this issue altogether.

> > > ---
> > >  void
> > >  AutoVacuumUpdateDelay(void)
> > >  {
> > > -        if (MyWorkerInfo)
> > > +        /*
> > > +         * We are using autovacuum-related GUCs to update
> > > VacuumCostDelay, so we
> > > +         * only want autovacuum workers and autovacuum launcher to d=
o this.
> > > +         */
> > > +        if (!(am_autovacuum_worker || am_autovacuum_launcher))
> > > +                return;
> > >
> > > Is there any case where the autovacuum launcher calls
> > > AutoVacuumUpdateDelay() function?
> >
> > I had meant to add it to HandleAutoVacLauncherInterrupts() after
> > reloading the config file (done in attached patch). When using the
> > global variables for cost delay (instead of wi_cost_delay in worker
> > info), the autovac launcher also has to do the check in the else branch
> > of AutoVacuumUpdateDelay()
> >
> >         VacuumCostDelay =3D autovacuum_vac_cost_delay >=3D 0 ?
> >             autovacuum_vac_cost_delay : VacuumCostDelay;
> >
> > to make sure VacuumCostDelay is correct for when it calls
> > autovac_balance_cost().
>
> But doesn't the launcher do a similar thing at the beginning of
> autovac_balance_cost()?
>
>     double      vac_cost_delay =3D (autovacuum_vac_cost_delay >=3D 0 ?
>                                   autovacuum_vac_cost_delay : VacuumCostD=
elay);

Ah, yes. You are right.

> Related to this point, I think autovac_balance_cost() should use
> globally-set cost_limit and cost_delay values to calculate worker's
> vacuum-delay parameters. IOW, vac_cost_limit and vac_cost_delay should
> come from the config file setting, not table option etc:
>
>     int         vac_cost_limit =3D (autovacuum_vac_cost_limit > 0 ?
>                                   autovacuum_vac_cost_limit : VacuumCostL=
imit);
>     double      vac_cost_delay =3D (autovacuum_vac_cost_delay >=3D 0 ?
>                                   autovacuum_vac_cost_delay : VacuumCostD=
elay);
>
> If my understanding is right, the following change is not right;
> AutoVacUpdateLimit() updates the VacuumCostLimit based on the value in
> MyWorkerInfo:
>
>                  MyWorkerInfo->wi_cost_limit_base =3D tab->at_vacuum_cost=
_limit;
> +                AutoVacuumUpdateLimit();
>
>                  /* do a balance */
>                  autovac_balance_cost();
>
> -                /* set the active cost parameters from the result of tha=
t */
> -                AutoVacuumUpdateDelay();
>
> Also, even when using the global variables for cost delay, the
> launcher doesn't need to check the global variable. It should always
> be able to use either autovacuum_vac_cost_delay/limit or
> VacuumCostDelay/Limit.

Yes, that is true. But, I actually think we can do something more
radical, which relates to this point as well as the issue with
cost_limit_base below.

> > This also made me think about whether or not we still need cost_limit_b=
ase.
> > It is used to ensure that autovac_balance_cost() never ends up setting
> > workers' wi_cost_limits above the current autovacuum_vacuum_cost_limit
> > (or VacuumCostLimit). However, the launcher and all the workers should
> > know what the value is without cost_limit_base, no?
>
> Yeah, the current balancing algorithm looks to respect the cost_limit
> value set when starting to vacuum the table. The proportion of the
> amount of I/O that a worker can consume is calculated based on the
> base value and the new worker's cost_limit value cannot exceed the
> base value. Given that we're trying to dynamically tune worker's cost
> parameters (delay and limit), this concept seems to need to be
> updated.

In master, autovacuum workers reload the config file at most once per
table vacuumed. And that is the same time that they update their
wi_cost_limit_base and wi_cost_delay. Thus, when autovac_balance_cost()
is called, there is a good chance that different workers will have
different values for wi_cost_limit_base and wi_cost_delay (and we are
only talking about workers not vacuuming a table with table option
cost-related gucs). So, it made sense that the balancing algorithm tried
to use a ratio to determine what to set the cost limit of each worker
to. It is clamped to the base value, as you say, but it also gives
workers a proportion of the new limit equal to what proportion their base
cost represents of the total cost.

I think all of this doesn't matter anymore now that everyone can reload
the config file often and dynamically change these values.

Thus, in the attached v5, I have removed both wi_cost_limit and wi_cost_del=
ay
from WorkerInfo. I've added a new variable to AutoVacuumShmem called
nworkers_for_balance. Now, autovac_balance_cost() only recalculates this
number and updates it if it has changed. Then, in
AutoVacuumUpdateLimit() workers read from this atomic value and divide
the value of the cost limit gucs by that number to get their own cost limit=
.

I keep the table option value of cost limit and cost delay in
backend-local memory to reference when updating the worker cost limit.

One nice thing is autovac_balance_cost() only requires an access shared
lock now (though most callers are updating other members before calling
it and still take an exclusive lock).

What do you think?

> > > > Also not sure how the patch interacts with failsafe autovac and par=
allel
> > > > vacuum.
> > >
> > > Good point.
> > >
> > > When entering the failsafe mode, we disable the vacuum delays (see
> > > lazy_check_wraparound_failsafe()). We need to keep disabling the
> > > vacuum delays even after reloading the config file. One idea is to
> > > have another global variable indicating we're in the failsafe mode.
> > > vacuum_delay_point() doesn't update VacuumCostActive if the flag is
> > > true.
> >
> > I think we might not need to do this. Other than in
> > lazy_check_wraparound_failsafe(), VacuumCostActive is only updated in
> > two places:
> >
> > 1) in vacuum() which autovacuum will call per table. And failsafe is
> > reset per table as well.
> >
> > 2) in vacuum_delay_point(), but, since VacuumCostActive will already be
> > false when we enter vacuum_delay_point() the next time after
> > lazy_check_wraparound_failsafe(), we won't set VacuumCostActive there.
>
> Indeed. But does it mean that there is no code path to turn
> vacuum-delay on, even when vacuum_cost_delay is updated from 0 to
> non-0?

Ah yes! Good point. This is true.
I'm not sure how to cheaply allow for re-enabling delays after disabling
them in the middle of a table vacuum.

I don't see a way around checking if we need to reload the config file
on every call to vacuum_delay_point() (currently, we are only doing this
when we have to wait anyway). It seems expensive to do this check every
time. If we do do this, we would update VacuumCostActive when updating
VacuumCostDelay, and we would need a global variable keeping the
failsafe status, as you mentioned.

It could be okay to say that you can only disable cost-based delays in
the middle of vacuuming a table (i.e. you cannot enable them if they are
already disabled until you start vacuuming the next table). Though maybe
it is weird that you can increase the delay but not re-enable it...

On an unrelated note, I was wondering if there were any docs anywhere
that should be updated to go along with this.

And, I was wondering if it was worth trying to split up the part that
reloads the config file and all of the autovacuum stuff. The reloading
of the config file by itself won't actually result in autovacuum workers
having updated cost delays because of them overwriting it with
wi_cost_delay, but it will allow VACUUM to have those updated values.

- Melanie

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