delta/go-git.git/src/context, branch dev.boringcrypto

all: gofmt main repo

2022-04-11T16:34:30+00:00

[This CL is part of a sequence implementing the proposal #51082.
The design doc is at https://go.dev/s/godocfmt-design.]

Run the updated gofmt, which reformats doc comments,
on the main repository. Vendored files are excluded.

For #51082.

Change-Id: I7332f099b60f716295fb34719c98c04eb1a85407
Reviewed-on: https://go-review.googlesource.com/c/go/+/384268
Reviewed-by: Jonathan Amsterdam 
Reviewed-by: Ian Lance Taylor

all: gofmt -w -r 'interface{} -> any' src

2021-12-13T18:45:54+00:00

And then revert the bootstrap cmd directories and certain testdata.
And adjust tests as needed.

Not reverting the changes in std that are bootstrapped,
because some of those changes would appear in API docs,
and we want to use any consistently.
Instead, rewrite 'any' to 'interface{}' in cmd/dist for those directories
when preparing the bootstrap copy.

A few files changed as a result of running gofmt -w
not because of interface{} -> any but because they
hadn't been updated for the new //go:build lines.

Fixes #49884.

Change-Id: Ie8045cba995f65bd79c694ec77a1b3d1fe01bb09
Reviewed-on: https://go-review.googlesource.com/c/go/+/368254
Trust: Russ Cox 
Run-TryBot: Russ Cox 
Reviewed-by: Robert Griesemer 
TryBot-Result: Gopher Robot

context: implement Context.Value using iteration rather than recursion

2021-10-02T00:44:24+00:00

In profiles of a production server, 2.3% of CPU time is spent in
runtime.newstack for stacks with 12 or more chained Context.Value
calls. Using iteration will avoid some needless stack resizes.

When calling Context.Value in the same goroutine (see
DeepValueSameGoRoutine) , no stack resizing is needed (after warming
up), and this change reduces time/op by around 10%.

The time to start a new goroutine and call Context.Value (see
DeepValueNewGoRoutine) is reduced by over 75% if a stack resize is
needed. If you factor out the overhead of starting the goroutine
(about 960ns) then, avoiding the stack resize saves about 95%.

```
name                                          old time/op  new time/op  delta
CommonParentCancel-12                          960ns ± 1%   958ns ± 1%     ~     (p=0.561 n=9+9)
WithTimeout/concurrency=40-12                 1.31µs ± 2%  1.29µs ± 6%     ~     (p=0.305 n=9+10)
WithTimeout/concurrency=4000-12               1.30µs ± 2%  1.30µs ± 2%     ~     (p=0.343 n=10+10)
WithTimeout/concurrency=400000-12             1.03µs ± 1%  1.02µs ± 2%     ~     (p=0.213 n=9+9)
CancelTree/depth=1/Root=Background-12          123ns ± 5%   126ns ± 2%   +2.61%  (p=0.023 n=10+9)
CancelTree/depth=1/Root=OpenCanceler-12        781ns ± 4%   806ns ± 4%   +3.20%  (p=0.022 n=9+10)
CancelTree/depth=1/Root=ClosedCanceler-12      370ns ± 4%   369ns ± 3%     ~     (p=0.497 n=9+10)
CancelTree/depth=10/Root=Background-12        4.74µs ± 4%  4.78µs ± 3%     ~     (p=0.516 n=10+10)
CancelTree/depth=10/Root=OpenCanceler-12      6.31µs ± 4%  6.29µs ± 4%     ~     (p=1.000 n=10+10)
CancelTree/depth=10/Root=ClosedCanceler-12    2.10µs ± 5%  2.09µs ± 5%     ~     (p=0.839 n=10+10)
CancelTree/depth=100/Root=Background-12       51.0µs ± 3%  51.2µs ± 2%     ~     (p=0.631 n=10+10)
CancelTree/depth=100/Root=OpenCanceler-12     60.8µs ± 1%  61.6µs ± 4%     ~     (p=0.274 n=8+10)
CancelTree/depth=100/Root=ClosedCanceler-12   19.3µs ± 2%  19.0µs ± 3%     ~     (p=0.123 n=10+10)
CancelTree/depth=1000/Root=Background-12       504µs ± 4%   512µs ± 4%     ~     (p=0.123 n=10+10)
CancelTree/depth=1000/Root=OpenCanceler-12     615µs ± 6%   619µs ± 4%     ~     (p=1.000 n=10+10)
CancelTree/depth=1000/Root=ClosedCanceler-12   190µs ± 2%   192µs ± 3%     ~     (p=0.190 n=9+9)
CheckCanceled/Err-12                          12.1ns ± 2%  12.1ns ± 2%     ~     (p=0.615 n=10+10)
CheckCanceled/Done-12                         7.27ns ± 1%  7.26ns ± 1%     ~     (p=0.698 n=10+10)
ContextCancelDone-12                          1.03ns ± 1%  1.03ns ± 1%     ~     (p=0.474 n=9+9)
DeepValueNewGoRoutine/depth=10-12             1.02µs ± 3%  0.99µs ± 2%   -3.41%  (p=0.000 n=10+10)
DeepValueNewGoRoutine/depth=20-12             1.11µs ± 3%  1.08µs ± 2%   -2.51%  (p=0.004 n=10+10)
DeepValueNewGoRoutine/depth=30-12             5.55µs ±10%  1.17µs ± 4%  -78.91%  (p=0.000 n=10+10)
DeepValueNewGoRoutine/depth=50-12             5.70µs ±13%  1.35µs ± 2%  -76.31%  (p=0.000 n=10+10)
DeepValueNewGoRoutine/depth=100-12            9.69µs ± 4%  1.82µs ± 2%  -81.18%  (p=0.000 n=10+10)
DeepValueSameGoRoutine/depth=10-12            54.2ns ± 2%  46.8ns ± 2%  -13.71%  (p=0.000 n=9+9)
DeepValueSameGoRoutine/depth=20-12             109ns ± 2%    97ns ± 2%  -11.11%  (p=0.000 n=10+10)
DeepValueSameGoRoutine/depth=30-12             155ns ± 3%   140ns ± 1%   -9.49%  (p=0.000 n=10+10)
DeepValueSameGoRoutine/depth=50-12             256ns ± 2%   226ns ± 2%  -11.83%  (p=0.000 n=10+10)
DeepValueSameGoRoutine/depth=100-12            492ns ± 3%   442ns ± 1%  -10.15%  (p=0.000 n=10+10)
```

Fixes #47292

Change-Id: I6bdeb234c979fb8fd6bfb91fd345cb5038f52c75
Reviewed-on: https://go-review.googlesource.com/c/go/+/335790
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
Trust: Damien Neil

all: fix spellings

2021-04-10T01:46:41+00:00

This follows the spelling choices that the Go project has made for English words.
https://github.com/golang/go/wiki/Spelling

Change-Id: Ie7c586d2cf23020cb492cfff58c0831d2d8d3a78
GitHub-Last-Rev: e16a32cd225a275f73d236bcb33703986d110ded
GitHub-Pull-Request: golang/go#45442
Reviewed-on: https://go-review.googlesource.com/c/go/+/308291
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
Trust: Emmanuel Odeke

context: avoid importing context package twice

2021-02-24T18:15:00+00:00

Change-Id: Id0a127e080dda8ee62738922c6de8caf3719dd68
Reviewed-on: https://go-review.googlesource.com/c/go/+/295949
Reviewed-by: Josh Bleecher Snyder 
Trust: Josh Bleecher Snyder 
Trust: Kevin Burke 
Run-TryBot: Josh Bleecher Snyder 
TryBot-Result: Go Bot

context: reduce contention in cancelCtx.Done

2021-02-24T16:38:32+00:00

Use an atomic.Value to hold the done channel.
Conveniently, we have a mutex handy to coordinate writes to it.

name                 old time/op  new time/op  delta
ContextCancelDone-8  67.5ns ±10%   2.2ns ±11%  -96.74%  (p=0.000 n=30+28)

Fixes #42564

Change-Id: I5d72e0e87fb221d4e230209e5fb4698bea4053c6
Reviewed-on: https://go-review.googlesource.com/c/go/+/288193
Trust: Josh Bleecher Snyder 
Trust: Sameer Ajmani 
Run-TryBot: Josh Bleecher Snyder 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills

context: fix XTestInterlockedCancels

2021-02-23T22:54:59+00:00

The test does not use Done channel, so fix that.

Change-Id: I795feab2e95de815b8b6ee7a7fd90f19f7af7db1
Reviewed-on: https://go-review.googlesource.com/c/go/+/294749
Reviewed-by: Sameer Ajmani 
Trust: Sameer Ajmani 
Trust: Cody Oss 
Run-TryBot: Sameer Ajmani 
TryBot-Result: Go Bot

context: fix a flaky timeout in TestLayersTimeout

2020-03-31T17:59:03+00:00

In CL 223019, I reduced the short timeout in the testLayers helper to
be even shorter than it was. That exposed a racy (time-dependent)
select later in the function, which failed in one of the slower
builders (android-386-emu).

Also streamline the test to make it easier to test with a very high -count flag:
- Run tests that sleep for shortDuration in parallel to reduce latency.
- Use shorter durations in examples to reduce test running time.
- Avoid mutating global state (in package math/rand) in testLayers.

After this change (but not before it),
'go test -run=TestLayersTimeout -count=100000 context' passes on my workstation.

Fixes #38161

Change-Id: Iaf4abe7ac308b2100d8828267cda9f4f8ae4be82
Reviewed-on: https://go-review.googlesource.com/c/go/+/226457
Reviewed-by: Ian Lance Taylor

context: prevent creation of invalid contexts

2020-03-18T19:44:13+00:00

This commit makes it impossible to create derived contexts with nil parents.
Previously it was possible to create derived contexts with nil parents, and
invalid contexts could propogate through the program. Eventually this can
cause a panic downstream, which is difficult to trace back to the source
of the error.

Although `WithCancel` and `WithDeadline` already panic if `parent` is `nil`, this adds explicit checks to give a useful message in the panic.

Fixes #37908

Change-Id: I70fd01f6539c1b0da0e775fc5457e32e7075e52c
GitHub-Last-Rev: 1b7dadd7db9ba42952644ad5e9a49591d6a5191f
GitHub-Pull-Request: golang/go#37898
Reviewed-on: https://go-review.googlesource.com/c/go/+/223777
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Gobot Gobot 
Reviewed-by: Ian Lance Taylor

context: deflake time-sensitive tests

2020-03-13T22:25:52+00:00

Many of tests in this package assumed reasonable scheduling latency.
Unfortunately, scheduling latency on builders and CI systems is not
always reasonable.

Rather than expecting that a timeout is detected within a fixed short
interval, we can use (*testing.T).Deadline to portably scale the time
we're willing to wait to something appropriate to the builder.

Some of the tests also included arbitrary-duration sleeps, which are
no longer needed after CL 196521; we can remove those instead of
extending them.

Promptness of timeouts is also an important property, but testing that
property is better suited to benchmarks than to tests proper: unlike
tests, we generally expect benchmarks to be run in a quiet,
low-contention environment.

Fixes #13956

Change-Id: I0797e2267fb778c8ad94add56d797de9e2c885e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/223019
Run-TryBot: Bryan C. Mills 
TryBot-Result: Gobot Gobot 
Reviewed-by: Ian Lance Taylor