MIME-Version: 1.0
References: <20200612232810.f46nbqkdhbutzqdg@alap3.anarazel.de>
In-Reply-To: <20200612232810.f46nbqkdhbutzqdg@alap3.anarazel.de>
From: Lukas Fittl <lukas@fittl.com>
Date: Fri, 1 Jul 2022 01:23:01 -0700
Message-ID: 
 <CAP53Pky+4MJfdC-R3HQFPRauy2N+5_7ExpEhCFUo8EU3bCPjEg@mail.gmail.com>
Subject: Re: Reduce timing overhead of EXPLAIN ANALYZE using rdtsc?
To: Andres Freund <andres@anarazel.de>
Cc: pgsql-hackers@postgresql.org
Content-Type: multipart/mixed; boundary="0000000000005873b905e2ba1a3d"
Archived-At: 
 <https://www.postgresql.org/message-id/CAP53Pky%2B4MJfdC-R3HQFPRauy2N%2B5_7ExpEhCFUo8EU3bCPjEg%40mail.gmail.com>
Precedence: bulk

--0000000000005873b905e2ba1a3d
Content-Type: multipart/alternative; boundary="0000000000005873b705e2ba1a3b"

--0000000000005873b705e2ba1a3b
Content-Type: text/plain; charset="UTF-8"

On Fri, Jun 12, 2020 at 4:28 PM Andres Freund <andres@anarazel.de> wrote:

> The attached patches are really just a prototype. I'm also not really
> planning to work on getting this into a "production ready" patchset
> anytime soon. I developed it primarily because I found it the overhead
> made it too hard to nail down in which part of a query tree performance
> changed.  If somebody else wants to continue from here...
>
> I do think it's be a pretty significant improvement if we could reduce
> the timing overhead of EXPLAIN ANALYZE by this much. Even if requires a
> bunch of low-level code.
>

Based on an off-list conversation with Andres, I decided to dust off this
old
patch for using rdtsc directly. The significant EXPLAIN ANALYZE performance
improvements (especially when using rdtsc instead of rdtsc*p*) seem to
warrant
giving this a more thorough look.

See attached an updated patch (adding it to the July commitfest), with a few
changes:

- Keep using clock_gettime() as a fallback if we decide to not use rdtsc
- Fallback to /proc/cpuinfo for clock frequency, if cpuid(0x16) doesn't work
- The decision to use rdtsc (or not) is made at runtime, in the new
  INSTR_TIME_INITIALIZE() -- we can't make this decision at compile time
  because this is dependent on the specific CPU in use, amongst other things
- In an abundance of caution, for now I've decided to only enable this if we
  are on Linux/x86, and the current kernel clocksource is TSC (the kernel
has
  quite sophisticated logic around making this decision, see [1])

Note that if we implemented the decision logic ourselves (instead of relying
on the Linux kernel), I'd be most worried about older virtualization
technology. In my understanding getting this right is notably more
complicated
than just checking cpuid, see [2].

Known WIP problems with this patch version:

* There appears to be a timing discrepancy I haven't yet worked out, where
  the \timing data reported by psql doesn't match what EXPLAIN ANALYZE is
  reporting. With Andres' earlier test case, I'm seeing a consistent ~700ms
  higher for \timing than for the EXPLAIN ANALYZE time reported on the
server
  side, only when rdtsc measurement is used -- its likely there is a problem
  somewhere with how we perform the cycles to time conversion
* Possibly related, the floating point handling for the cycles_to_sec
variable
  is problematic in terms of precision (see FIXME, taken over from Andres'
POC)

Open questions from me:

1) Do we need to account for different TSC offsets on different CPUs in SMP
   systems? (the Linux kernel certainly has logic to that extent, but [3]
   suggests this is no longer a problem on Nehalem and newer chips, i.e.
those
   having an invariant TSC)

2) Should we have a setting "--with-tsc" for configure? (instead of always
   enabling it when on Linux/x86 with a TSC clocksource)

3) Are there cases where we actually want to use rdtsc*p*? (i.e. wait for
   current instructions to finish -- the prior discussion seemed to suggest
   we don't want it for node instruction measurements, but possibly we do
want
   this in other cases?)

4) Should we support using the "mrs" instruction on ARM? (which is similar
to
   rdtsc, see [4])

Thanks,
Lukas

[1] https://github.com/torvalds/linux/blob/master/arch/x86/kernel/tsc.c
[2] http://oliveryang.net/2015/09/pitfalls-of-TSC-usage/
[3] https://stackoverflow.com/a/11060619/1652607
[4] https://cpufun.substack.com/p/fun-with-timers-and-cpuid

-- 
Lukas Fittl

--0000000000005873b705e2ba1a3b
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div dir=3D"ltr">On Fri, Jun 12, 2020 at 4:28 PM Andres Fr=
eund &lt;<a href=3D"mailto:andres@anarazel.de">andres@anarazel.de</a>&gt; w=
rote:<br></div><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote"=
 style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);p=
adding-left:1ex">
The attached patches are really just a prototype. I&#39;m also not really<b=
r>
planning to work on getting this into a &quot;production ready&quot; patchs=
et<br>
anytime soon. I developed it primarily because I found it the overhead<br>
made it too hard to nail down in which part of a query tree performance<br>
changed.=C2=A0 If somebody else wants to continue from here...<br>
<br>
I do think it&#39;s be a pretty significant improvement if we could reduce<=
br>
the timing overhead of EXPLAIN ANALYZE by this much. Even if requires a<br>
bunch of low-level code.<br>
</blockquote></div><br><div>Based on an off-list conversation with Andres, =
I decided to dust off this old<br>patch for using rdtsc directly. The signi=
ficant EXPLAIN ANALYZE performance<br>improvements (especially when using r=
dtsc instead of rdtsc*p*) seem to warrant<br>giving this a more thorough lo=
ok.<br><br>See attached an updated patch (adding it to the July commitfest)=
, with a few<br>changes:<br><br>- Keep using clock_gettime() as a fallback =
if we decide to not use rdtsc<br>- Fallback to /proc/cpuinfo for clock freq=
uency, if cpuid(0x16) doesn&#39;t work<br>- The decision to use rdtsc (or n=
ot) is made at runtime, in the new<br>=C2=A0 INSTR_TIME_INITIALIZE() -- we =
can&#39;t make this decision at compile time<br>=C2=A0 because this is depe=
ndent on the specific CPU in use, amongst other things<br>- In an abundance=
 of caution, for now I&#39;ve decided to only enable this if we<br>=C2=A0 a=
re on Linux/x86, and the current kernel clocksource is TSC (the kernel has<=
br>=C2=A0 quite sophisticated logic around making this decision, see [1])<b=
r><br>Note that if we implemented the decision logic ourselves (instead of =
relying<br>on the Linux kernel), I&#39;d be most worried about older virtua=
lization<br>technology. In my understanding getting this right is notably m=
ore complicated<br>than just checking cpuid, see [2].<br><br>Known WIP prob=
lems with this patch version:<br><br>* There appears to be a timing discrep=
ancy I haven&#39;t yet worked out, where<br>=C2=A0 the \timing data reporte=
d by psql doesn&#39;t match what EXPLAIN ANALYZE is<br>=C2=A0 reporting. Wi=
th Andres&#39; earlier test case, I&#39;m seeing a consistent ~700ms<br>=C2=
=A0 higher for \timing than for the EXPLAIN ANALYZE time reported on the se=
rver<br>=C2=A0 side, only when rdtsc measurement is used -- its likely ther=
e is a problem<br>=C2=A0 somewhere with how we perform the cycles to time c=
onversion<br>* Possibly related, the floating point handling for the cycles=
_to_sec variable<br>=C2=A0 is problematic in terms of precision (see FIXME,=
 taken over from Andres&#39; POC)<br><br>Open questions from me:<br><br>1) =
Do we need to account for different TSC offsets on different CPUs in SMP<br=
>=C2=A0 =C2=A0systems? (the Linux kernel certainly has logic to that extent=
, but [3]<br>=C2=A0 =C2=A0suggests this is no longer a problem on Nehalem a=
nd newer chips, i.e. those<br>=C2=A0 =C2=A0having an invariant TSC)<br><br>=
2) Should we have a setting &quot;--with-tsc&quot; for configure? (instead =
of always<br>=C2=A0 =C2=A0enabling it when on Linux/x86 with a TSC clocksou=
rce)<br><br>3) Are there cases where we actually want to use rdtsc*p*? (i.e=
. wait for<br>=C2=A0 =C2=A0current instructions to finish -- the prior disc=
ussion seemed to suggest<br>=C2=A0 =C2=A0we don&#39;t want it for node inst=
ruction measurements, but possibly we do want<br>=C2=A0 =C2=A0this in other=
 cases?)<br><br>4) Should we support using the &quot;mrs&quot; instruction =
on ARM? (which is similar to<br>=C2=A0 =C2=A0rdtsc, see [4])<br><br>Thanks,=
<br>Lukas<br><br>[1] <a href=3D"https://github.com/torvalds/linux/blob/mast=
er/arch/x86/kernel/tsc.c">https://github.com/torvalds/linux/blob/master/arc=
h/x86/kernel/tsc.c</a><br>[2] <a href=3D"http://oliveryang.net/2015/09/pitf=
alls-of-TSC-usage/">http://oliveryang.net/2015/09/pitfalls-of-TSC-usage/</a=
><br>[3] <a href=3D"https://stackoverflow.com/a/11060619/1652607">https://s=
tackoverflow.com/a/11060619/1652607</a><br>[4] <a href=3D"https://cpufun.su=
bstack.com/p/fun-with-timers-and-cpuid">https://cpufun.substack.com/p/fun-w=
ith-timers-and-cpuid</a><br></div><br>-- <br><div dir=3D"ltr" class=3D"gmai=
l_signature"><div dir=3D"ltr"><div><div dir=3D"ltr"><div><div dir=3D"ltr">L=
ukas Fittl</div></div></div></div></div></div></div>

--0000000000005873b705e2ba1a3b--

--0000000000005873b905e2ba1a3d
Content-Type: application/octet-stream;
	name="v2-0002-WIP-Use-cpu-reference-cycles-via-rdtsc-to-measure.patch"
Content-Disposition: attachment;
	filename="v2-0002-WIP-Use-cpu-reference-cycles-via-rdtsc-to-measure.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_l526suja1>
X-Attachment-Id: f_l526suja1
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--0000000000005873b905e2ba1a3d
Content-Type: application/octet-stream;
	name="v2-0001-WIP-Change-instr_time-to-just-store-nanoseconds-t.patch"
Content-Disposition: attachment;
	filename="v2-0001-WIP-Change-instr_time-to-just-store-nanoseconds-t.patch"
Content-Transfer-Encoding: base64
Content-ID: <f_l526suj20>
X-Attachment-Id: f_l526suj20

RnJvbSAwYzY5MGM3NmNiNGNjZmM5OTVlYjk4MzQwNjI4ZjEwMjc0ZDg5YzgxIE1vbiBTZXAgMTcg
MDA6MDA6MDAgMjAwMQpGcm9tOiBMdWthcyBGaXR0bCA8bHVrYXNAZml0dGwuY29tPgpEYXRlOiBU
aHUsIDMwIEp1biAyMDIyIDE3OjU1OjMyIC0wNzAwClN1YmplY3Q6IFtQQVRDSCB2MiAxLzJdIFdJ
UDogQ2hhbmdlIGluc3RyX3RpbWUgdG8ganVzdCBzdG9yZSBuYW5vc2Vjb25kcywKIHRoYXQncyBj
aGVhcGVyLgoKQXV0aG9yOiBBbmRyZXMgRnJldW5kClJldmlld2VkLUJ5OgpEaXNjdXNzaW9uOiBo
dHRwczovL3Bvc3Rnci5lcy9tLwpCYWNrcGF0Y2g6Ci0tLQogc3JjL2luY2x1ZGUvcG9ydGFiaWxp
dHkvaW5zdHJfdGltZS5oIHwgNjIgKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLQogMSBmaWxl
IGNoYW5nZWQsIDI2IGluc2VydGlvbnMoKyksIDM2IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh
L3NyYy9pbmNsdWRlL3BvcnRhYmlsaXR5L2luc3RyX3RpbWUuaCBiL3NyYy9pbmNsdWRlL3BvcnRh
YmlsaXR5L2luc3RyX3RpbWUuaAppbmRleCBjYTA5YTE2MDhmLi5jYTI2MDAzMmQxIDEwMDY0NAot
LS0gYS9zcmMvaW5jbHVkZS9wb3J0YWJpbGl0eS9pbnN0cl90aW1lLmgKKysrIGIvc3JjL2luY2x1
ZGUvcG9ydGFiaWxpdHkvaW5zdHJfdGltZS5oCkBAIC04Myw2MyArODMsNTMgQEAKICNkZWZpbmUg
UEdfSU5TVFJfQ0xPQ0sJQ0xPQ0tfUkVBTFRJTUUKICNlbmRpZgogCi10eXBlZGVmIHN0cnVjdCB0
aW1lc3BlYyBpbnN0cl90aW1lOwordHlwZWRlZiBpbnQ2NCBpbnN0cl90aW1lOworI2RlZmluZSBO
U19QRVJfUyBJTlQ2NENPTlNUKDEwMDAwMDAwMDApCisjZGVmaW5lIFVTX1BFUl9TIElOVDY0Q09O
U1QoMTAwMDAwMCkKKyNkZWZpbmUgTVNfUEVSX1MgSU5UNjRDT05TVCgxMDAwKQogCi0jZGVmaW5l
IElOU1RSX1RJTUVfSVNfWkVSTyh0KQkoKHQpLnR2X25zZWMgPT0gMCAmJiAodCkudHZfc2VjID09
IDApCisjZGVmaW5lIE5TX1BFUl9NUyBJTlQ2NENPTlNUKDEwMDAwMDApCisjZGVmaW5lIE5TX1BF
Ul9VUyBJTlQ2NENPTlNUKDEwMDApCiAKLSNkZWZpbmUgSU5TVFJfVElNRV9TRVRfWkVSTyh0KQko
KHQpLnR2X3NlYyA9IDAsICh0KS50dl9uc2VjID0gMCkKKyNkZWZpbmUgSU5TVFJfVElNRV9JU19a
RVJPKHQpCSgodCkgPT0gMCkKIAotI2RlZmluZSBJTlNUUl9USU1FX1NFVF9DVVJSRU5UKHQpCSgo
dm9pZCkgY2xvY2tfZ2V0dGltZShQR19JTlNUUl9DTE9DSywgJih0KSkpCisjZGVmaW5lIElOU1RS
X1RJTUVfU0VUX1pFUk8odCkJKCh0KSA9IDApCisKK3N0YXRpYyBpbmxpbmUgaW5zdHJfdGltZSBw
Z19jbG9ja19nZXR0aW1lX25zKHZvaWQpCit7CisJc3RydWN0IHRpbWVzcGVjIHRtcDsKKworCWNs
b2NrX2dldHRpbWUoUEdfSU5TVFJfQ0xPQ0ssICZ0bXApOworCisJcmV0dXJuIHRtcC50dl9zZWMg
KiBOU19QRVJfUyArIHRtcC50dl9uc2VjOworfQorCisjZGVmaW5lIElOU1RSX1RJTUVfU0VUX0NV
UlJFTlQodCkgXAorCSh0KSA9IHBnX2Nsb2NrX2dldHRpbWVfbnMoKQogCiAjZGVmaW5lIElOU1RS
X1RJTUVfQUREKHgseSkgXAogCWRvIHsgXAotCQkoeCkudHZfc2VjICs9ICh5KS50dl9zZWM7IFwK
LQkJKHgpLnR2X25zZWMgKz0gKHkpLnR2X25zZWM7IFwKLQkJLyogTm9ybWFsaXplICovIFwKLQkJ
d2hpbGUgKCh4KS50dl9uc2VjID49IDEwMDAwMDAwMDApIFwKLQkJeyBcCi0JCQkoeCkudHZfbnNl
YyAtPSAxMDAwMDAwMDAwOyBcCi0JCQkoeCkudHZfc2VjKys7IFwKLQkJfSBcCisJCSh4KSArPSAo
eSk7IFwKIAl9IHdoaWxlICgwKQogCiAjZGVmaW5lIElOU1RSX1RJTUVfU1VCVFJBQ1QoeCx5KSBc
CiAJZG8geyBcCi0JCSh4KS50dl9zZWMgLT0gKHkpLnR2X3NlYzsgXAotCQkoeCkudHZfbnNlYyAt
PSAoeSkudHZfbnNlYzsgXAotCQkvKiBOb3JtYWxpemUgKi8gXAotCQl3aGlsZSAoKHgpLnR2X25z
ZWMgPCAwKSBcCi0JCXsgXAotCQkJKHgpLnR2X25zZWMgKz0gMTAwMDAwMDAwMDsgXAotCQkJKHgp
LnR2X3NlYy0tOyBcCi0JCX0gXAorCQkoeCkgLT0gKHkpOyBcCiAJfSB3aGlsZSAoMCkKIAogI2Rl
ZmluZSBJTlNUUl9USU1FX0FDQ1VNX0RJRkYoeCx5LHopIFwKIAlkbyB7IFwKLQkJKHgpLnR2X3Nl
YyArPSAoeSkudHZfc2VjIC0gKHopLnR2X3NlYzsgXAotCQkoeCkudHZfbnNlYyArPSAoeSkudHZf
bnNlYyAtICh6KS50dl9uc2VjOyBcCi0JCS8qIE5vcm1hbGl6ZSBhZnRlciBlYWNoIGFkZCB0byBh
dm9pZCBvdmVyZmxvdy91bmRlcmZsb3cgb2YgdHZfbnNlYyAqLyBcCi0JCXdoaWxlICgoeCkudHZf
bnNlYyA8IDApIFwKLQkJeyBcCi0JCQkoeCkudHZfbnNlYyArPSAxMDAwMDAwMDAwOyBcCi0JCQko
eCkudHZfc2VjLS07IFwKLQkJfSBcCi0JCXdoaWxlICgoeCkudHZfbnNlYyA+PSAxMDAwMDAwMDAw
KSBcCi0JCXsgXAotCQkJKHgpLnR2X25zZWMgLT0gMTAwMDAwMDAwMDsgXAotCQkJKHgpLnR2X3Nl
YysrOyBcCi0JCX0gXAorCQkoeCkgKz0gKHkpIC0gKHopOyBcCiAJfSB3aGlsZSAoMCkKIAogI2Rl
ZmluZSBJTlNUUl9USU1FX0dFVF9ET1VCTEUodCkgXAotCSgoKGRvdWJsZSkgKHQpLnR2X3NlYykg
KyAoKGRvdWJsZSkgKHQpLnR2X25zZWMpIC8gMTAwMDAwMDAwMC4wKQorCSgoZG91YmxlKSAodCkg
LyBOU19QRVJfUykKIAogI2RlZmluZSBJTlNUUl9USU1FX0dFVF9NSUxMSVNFQyh0KSBcCi0JKCgo
ZG91YmxlKSAodCkudHZfc2VjICogMTAwMC4wKSArICgoZG91YmxlKSAodCkudHZfbnNlYykgLyAx
MDAwMDAwLjApCisJKChkb3VibGUpICh0KSAvIE5TX1BFUl9NUykKIAogI2RlZmluZSBJTlNUUl9U
SU1FX0dFVF9NSUNST1NFQyh0KSBcCi0JKCgodWludDY0KSAodCkudHZfc2VjICogKHVpbnQ2NCkg
MTAwMDAwMCkgKyAodWludDY0KSAoKHQpLnR2X25zZWMgLyAxMDAwKSkKKwkoKGRvdWJsZSkgKHQp
IC8gTlNfUEVSX1VTKQogCiAjZWxzZQkJCQkJCQkvKiAhSEFWRV9DTE9DS19HRVRUSU1FICovCiAK
LS0gCjIuMzQuMAoK
--0000000000005873b905e2ba1a3d--