time: use longer delta duration for TestAfterQueueing retries
The TestAfterQueueing test is inherently flaky because it relies on
independent kernel threads being scheduled within the "delta" duration
of each other. Normally, delta is 100ms but during "short" testing,
it's reduced to 20ms.
On at least OpenBSD, the CPU scheduler operates in 10ms time slices,
so high system load (e.g., from running multiple Go unit tests in
parallel, as happens during all.bash) can occasionally cause >20ms
scheduling delays and result in test flaking. This manifests as issue
9903, which is the currently the most common OpenBSD flake.
To mitigate this delay, only reduce the delta duration to 20ms for the
first attempt during short testing. If this fails and the test is
reattempted, subsequent attempts instead use a full 100ms delta.
Fixes #9903.
Change-Id: I11bdfa939e5be915f67ffad8a8aef6ed8772159a
Reviewed-on: https://go-review.googlesource.com/9510
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
diff --git a/src/time/sleep_test.go b/src/time/sleep_test.go
index 6452a9e..d0962ec 100644
--- a/src/time/sleep_test.go
+++ b/src/time/sleep_test.go
@@ -227,7 +227,11 @@
const attempts = 3
err := errors.New("!=nil")
for i := 0; i < attempts && err != nil; i++ {
- if err = testAfterQueuing(t); err != nil {
+ delta := 100 * Millisecond
+ if i == 0 && testing.Short() {
+ delta = 20 * Millisecond
+ }
+ if err = testAfterQueuing(t, delta); err != nil {
t.Logf("attempt %v failed: %v", i, err)
}
}
@@ -247,11 +251,7 @@
result <- afterResult{slot, <-ac}
}
-func testAfterQueuing(t *testing.T) error {
- Delta := 100 * Millisecond
- if testing.Short() {
- Delta = 20 * Millisecond
- }
+func testAfterQueuing(t *testing.T, delta Duration) error {
// make the result channel buffered because we don't want
// to depend on channel queueing semantics that might
// possibly change in the future.
@@ -259,7 +259,7 @@
t0 := Now()
for _, slot := range slots {
- go await(slot, result, After(Duration(slot)*Delta))
+ go await(slot, result, After(Duration(slot)*delta))
}
sort.Ints(slots)
for _, slot := range slots {
@@ -268,9 +268,9 @@
return fmt.Errorf("after slot %d, expected %d", r.slot, slot)
}
dt := r.t.Sub(t0)
- target := Duration(slot) * Delta
- if dt < target-Delta/2 || dt > target+Delta*10 {
- return fmt.Errorf("After(%s) arrived at %s, expected [%s,%s]", target, dt, target-Delta/2, target+Delta*10)
+ target := Duration(slot) * delta
+ if dt < target-delta/2 || dt > target+delta*10 {
+ return fmt.Errorf("After(%s) arrived at %s, expected [%s,%s]", target, dt, target-delta/2, target+delta*10)
}
}
return nil
