runtime, time: don't use monotonic clock inside synctest bubbles

Don't include a monotonic time in time.Times created inside
a bubble, to avoid the confusion of different Times using
different monotonic clock epochs.

For #67434

goos: darwin
goarch: arm64
pkg: time
cpu: Apple M1 Pro
         │ /tmp/bench.0 │            /tmp/bench.1            │
         │    sec/op    │   sec/op     vs base               │
Since-10    18.42n ± 2%   18.68n ± 1%       ~ (p=0.101 n=10)
Until-10    18.28n ± 2%   18.46n ± 2%  +0.98% (p=0.009 n=10)
geomean     18.35n        18.57n       +1.20%

Change-Id: Iaf1b80d0a4df52139c5b80d4bde4410ef8a49f2f
Reviewed-on: https://go-review.googlesource.com/c/go/+/657415
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Damien Neil <dneil@google.com>
Reviewed-by: Michael Pratt <mpratt@google.com>

1 files changed, 12 insertions, 1 deletions

diff --git a/src/runtime/time.go b/src/runtime/time.go
index c22d39c089..3ece161cf4 100644
--- a/src/runtime/time.go
+++ b/src/runtime/time.go
@@ -18,7 +18,13 @@ func time_runtimeNow() (sec int64, nsec int32, mono int64) {
 	if sg := getg().syncGroup; sg != nil {
 		sec = sg.now / (1000 * 1000 * 1000)
 		nsec = int32(sg.now % (1000 * 1000 * 1000))
-		return sec, nsec, sg.now
+		// Don't return a monotonic time inside a synctest bubble.
+		// If we return a monotonic time based on the fake clock,
+		// arithmetic on times created inside/outside bubbles is confusing.
+		// If we return a monotonic time based on the real monotonic clock,
+		// arithmetic on times created in the same bubble is confusing.
+		// Simplest is to omit the monotonic time within a bubble.
+		return sec, nsec, 0
 	}
 	return time_now()
 }
@@ -32,6 +38,11 @@ func time_runtimeNano() int64 {
 	return nanotime()
 }
 
+//go:linkname time_runtimeIsBubbled time.runtimeIsBubbled
+func time_runtimeIsBubbled() bool {
+	return getg().syncGroup != nil
+}
+
 // A timer is a potentially repeating trigger for calling t.f(t.arg, t.seq).
 // Timers are allocated by client code, often as part of other data structures.
 // Each P has a heap of pointers to timers that it manages.