|From:||Robert Haas <robertmhaas(at)gmail(dot)com>|
|To:||Amit Khandekar <amitdkhan(dot)pg(at)gmail(dot)com>|
|Cc:||Andres Freund <andres(at)anarazel(dot)de>, Haribabu Kommi <kommi(dot)haribabu(at)gmail(dot)com>, Asim R P <apraveen(at)pivotal(dot)io>, Pg Hackers <pgsql-hackers(at)postgresql(dot)org>, Ashwin Agrawal <aagrawal(at)pivotal(dot)io>, Dmitry Dolgov <9erthalion6(at)gmail(dot)com>, Alvaro Herrera <alvherre(at)2ndquadrant(dot)com>, Alexander Korotkov <a(dot)korotkov(at)postgrespro(dot)ru>|
|Subject:||Re: Pluggable Storage - Andres's take|
|Views:||Raw Message | Whole Thread | Download mbox|
On Thu, Feb 21, 2019 at 6:44 AM Amit Khandekar <amitdkhan(dot)pg(at)gmail(dot)com> wrote:
> Ok, so something like XidHorizonPrefetchState ? On similar lines, does
> prefetch_buffer() function name sound too generic as well ?
Yeah, that sounds good. And, yeah, then maybe rename the function too.
> > +/*
> > + * An arbitrary way to come up with a pre-fetch distance that grows with io
> > + * concurrency, but is at least 10 and not more than the max effective io
> > + * concurrency.
> > + */
> > This comment is kinda useless, because it only tells us what the code
> > does (which is obvious anyway) and not why it does that. Saying that
> > your formula is arbitrary may not be the best way to attract support
> > for it.
> Well, I had checked the way the number of drive spindles
> (effective_io_concurrency) is used to calculate the prefetch distance
> for bitmap heap scans (ComputeIoConcurrency). Basically I think the
> intention behind that method is to come up with a number that makes it
> highly likely that we pre-fetch a block of each of the drive spindles.
> But I didn't get how that exactly works, all the less for non-parallel
> bitmap scans. Same is the case for the pre-fetching that we do here
> for xid-horizon stuff, where we do the block reads sequentially. Me
> and Andres discussed this offline, and he was of the opinion that this
> formula won't help here, and instead we just keep a constant distance
> that is some number greater than effective_io_concurrency. I agree
> that instead of saying "arbitrary" we should explain why we have done
> that, and before that, come up with an agreed-upon formula.
Maybe something like: We don't use the regular formula to determine
how much to prefetch here, but instead just add a constant to
effective_io_concurrency. That's because it seems best to do some
prefetching here even when effective_io_concurrency is set to 0, but
if the DBA thinks it's OK to do more prefetching for other operations,
then it's probably OK to do more prefetching in this case, too. It
may be that this formula is too simplistic, but at the moment we have
no evidence of that or any idea about what would work better.
> > + for (i = prefetch_state->next_item; i < nitems && count < prefetch_count; i++)
> > It looks strange to me that next_item is stored in prefetch_state and
> > nitems is passed around as an argument. Is there some reason why it's
> > like that?
> We could keep the max count in the structure itself as well. There
> isn't any specific reason for not keeping it there. It's just that
> this function prefetch_state () is not a general function for
> maintaining a prefetch state that spans across function calls; so we
> might as well just pass the max count to that function instead of
> having another field in that structure. I am not inclined specifically
> towards either of the approaches.
All right, count me as +0.5 for putting a copy in the structure.
The Enterprise PostgreSQL Company
|Next Message||Robert Haas||2019-02-21 12:45:32||Re: [PROPOSAL] Shared Ispell dictionaries|
|Previous Message||Amit Khandekar||2019-02-21 11:43:45||Re: Pluggable Storage - Andres's take|