- 02 Nov, 2019 5 commits
-
-
Keith Randall authored
Fixes #34778 Change-Id: If8225a7c41cb2af3f67157fb9670eef86272e85e Reviewed-on: https://go-review.googlesource.com/c/go/+/204997 Run-TryBot: Keith Randall <khr@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
Brad Fitzpatrick <bradfitz@golang.org>
-
Katie Hockman authored
Even though bitwise operations may be slightly more performant, the readability improvement of a mod operation is worth the tradeoff. Change-Id: I352c92ad355c6eb6ef99e3da00e1eff2d2ea5812 Reviewed-on: https://go-review.googlesource.com/c/go/+/204739Reviewed-by:
Filippo Valsorda <filippo@golang.org> Run-TryBot: Filippo Valsorda <filippo@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
-
Ian Lance Taylor authored
Updates #10958 Updates #24543 Fixes #35294 Change-Id: I60f024d08451565df6d9751dab9832b50cbf637a Reviewed-on: https://go-review.googlesource.com/c/go/+/204957 Run-TryBot: Ian Lance Taylor <iant@golang.org> Reviewed-by:
Cherry Zhang <cherryyz@google.com>
-
Joshua M. Clulow authored
On illumos systems, and at least historically on Solaris systems, it is possible for port_getn(3C) calls to return some number of events and then fail with error ETIME. Generally we expect this to happen if the caller passes an nget value larger than 1 and calls with a timeout; if less than the requested number of events accumulate the system will still return them after timeout failure so the caller must check the updated nget value in the ETIME case. Note that although less likely this can still happen even when requesting just 1 event, especially with a short timeout value or on a busy system. Fixes #35261 Change-Id: I0d83251b69a2fadc64c4e8e280aa596e2e1548ba Reviewed-on: https://go-review.googlesource.com/c/go/+/204801Reviewed-by:
Ian Lance Taylor <iant@golang.org> Reviewed-by:
-
Constantin Konstantinidis authored
Goroutines clean up takes longer when using deprecated CloseNotifier. Fixes #35122 Change-Id: Id820a3012b5c781ddfb294b38ee3b009624e398c Reviewed-on: https://go-review.googlesource.com/c/go/+/204661 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by:
-
- 01 Nov, 2019 17 commits
-
-
Ian Lance Taylor authored
If multiple goroutines call time.(*Timer).Reset then the timer will go from timerWaiting to timerDeleted to timerModifying to timerModifiedLater. The timer can be on a different P, meaning that simultaneously cleantimers could change it from timerDeleted to timerRemoving to timerRemoved. If Reset sees timerRemoved, it was doing an atomic.Store of timerWaiting, meaning that it did not necessarily see the other values set in the timer, so the timer could appear to be in an inconsistent state. Use atomic.Cas to avoid that possibility. Updates #6239 Updates #27707 Fixes #35272 Change-Id: I1d59a13dc4f2ff4af110fc6e032c8c9d59cfc270 Reviewed-on: https://go-review.googlesource.com/c/go/+/204717 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
Michael Knyszek <mknyszek@google.com>
-
Cuong Manh Le authored
In CL 204617, I intend to make "bound" parameter to have special meaning in typecheckarraylit, so we can distinguish between type-checks array literal and slice literal. But we end up with other solution. The CL was submitted without reverting the "bound" parameter in case of slice literal. Technically, it's not harmful, but causes the code harder to read and maintain. Change-Id: Ia522ccc9a6b8e25d7eaad4aa4957cb4fa18edc60 Reviewed-on: https://go-review.googlesource.com/c/go/+/204618 Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
Matthew Dempsky <mdempsky@google.com>
-
Domas Tamašauskas authored
User's program was mutating time.Local variable and crashing itself as a consequence. Instead of documenting that time.Local variable should not be mutated, recommended way of setting the system's time zone has been documented. Fixes #34814 Change-Id: I7781189855c3bf2ea979dfa07f86c283eed27091 Reviewed-on: https://go-review.googlesource.com/c/go/+/200457Reviewed-by:
-
Ian Lance Taylor authored
I was doing some testing with GODEBUG=schedtrace=1,scheddetail=1 and I noticed that the program hung after a throw with "all goroutines are asleep". This is because when doing a throw or fatal panic with schedtrace the panic code does a final schedtrace, which needs to acquire the scheduler lock. The checkdead function is always called with the scheduler lock held. So checkdead would throw with the scheduler lock held, then the panic code would call schedtrace, which would block trying to acquire the scheduler lock. This problem will only happen for people debugging the runtime, but it's easy to avoid by having checkdead unlock the scheduler lock before it throws. I only did this for the throws that can happen for a normal program, not for throws that indicate some corruption in the scheduler data. Change-Id: Ic62277b3ca6bee6f0fca8d5eb516c59cb67855cb Reviewed-on: https://go-review.googlesource.com/c/go/+/204778 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
Michael Anthony Knyszek authored
This change turns off the scavenger if there's less than one physical page of work to do. If there's less than one phyiscal page of work today, then the computed time for the work to be done will be zero, resulting in a floating point division by zero. This is bad on two accounts. On the one hand it could cause a fault on some systems. On the other hand, it could cause the pacing computations done by the scavenger to be nonsense. While this is generally harmless in the case where there's a very small amount of work to do anyway (the scavenger might just back off expontentially forever, or do some work and immediately sleep, because there's not much of it to do), it causes problems for the deadlock checker. On platforms with a larger physical page size, such as 64 KiB, we might hit this path in a deadlock scenario, in which case the deadlock checker will never fire and we'll just hang. Specifically, this happens on ppc64 trybot tests, which is where the issue was discovered. Fixes #34575. Change-Id: I8677db539447b2f0e75b8cfcbe33932244e1508c Reviewed-on: https://go-review.googlesource.com/c/go/+/203517 Run-TryBot: Michael Knyszek <mknyszek@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
Austin Clements <austin@google.com>
-
Brad Fitzpatrick authored
For debugging. (The "go1.4" can be misleading since it might actually be go1.4.3 or go1.11 or go1.12 or master) Change-Id: I27520b931a2be018de577a299592d082260aa467 Reviewed-on: https://go-review.googlesource.com/c/go/+/204757 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
Bryan C. Mills authored
Suppress “finding” messages unless they are unusually slow, and “extracting” messages always (they almost always occur conjunction with “downloading”, which is already logged). Log “found” messages for module dependencies added to satisfy missing import paths. Log top-level version changes in 'go get' when the selected version is not identical to the version requested on the command line. Updates #26152 Updates #33284 Change-Id: I4d0de60fab58d7cc7df8a2aff05c8b5b2220e626 Reviewed-on: https://go-review.googlesource.com/c/go/+/204777 Run-TryBot: Bryan C. Mills <bcmills@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
Jay Conrod <jayconrod@google.com>
-
Lorenz Bauer authored
A majority of work is spent in dataSize when en/decoding the same struct over and over again. This wastes a lot of work, since the result doesn't change for a given reflect.Value. Cache the result of the function for structs, so that subsequent calls to dataSize can avoid doing work. name old time/op new time/op delta ReadStruct 1.00µs ± 1% 0.37µs ± 1% -62.99% (p=0.029 n=4+4) WriteStruct 1.00µs ± 3% 0.37µs ± 1% -62.69% (p=0.008 n=5+5) name old speed new speed delta ReadStruct 75.1MB/s ± 1% 202.9MB/s ± 1% +170.16% (p=0.029 n=4+4) WriteStruct 74.8MB/s ± 3% 200.4MB/s ± 1% +167.96% (p=0.008 n=5+5) Fixes #34471 Change-Id: Ic5d987ca95f1197415ef93643a0af6fc1224fdf0 Reviewed-on: https://go-review.googlesource.com/c/go/+/199539Reviewed-by: -
Bryan C. Mills authored
Updates #30185 Updates #33326 Updates #34822 Change-Id: Ie13651585898d1bbbf4f779b97ee50b6c7e7ad50 Reviewed-on: https://go-review.googlesource.com/c/go/+/204521 Run-TryBot: Bryan C. Mills <bcmills@google.com> Reviewed-by:
-
Tobias Klauser authored
Based on the riscv-go port and the linux/riscv64 files in x/sys/unix. Updates #27532 Change-Id: Ib33a59a61f6b2721b12292c18f1fc9f9d0509cd3 Reviewed-on: https://go-review.googlesource.com/c/go/+/204659 Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
empijei authored
The current implementation performs a plain map lookup, but other header methods canonicalize header keys before using them. Fixes #34918 Change-Id: Id4120488b8b39ecee97fa7a6ad8a34158687ffcd Reviewed-on: https://go-review.googlesource.com/c/go/+/201357Reviewed-by:
-
Tobias Klauser authored
Based on the riscv-go port. Updates #27532 Change-Id: I3a4d86783fbd625e3ade16d08f87d66e4502f3f7 Reviewed-on: https://go-review.googlesource.com/c/go/+/204660 Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
Jay Conrod authored
Updates #35290 Change-Id: I09cad17f09e78c2bf6a9de98b01f13ed383ca006 Reviewed-on: https://go-review.googlesource.com/c/go/+/204643 Run-TryBot: Jay Conrod <jayconrod@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
Bryan C. Mills <bcmills@google.com>
-
Tobias Klauser authored
Change-Id: Ie76303e403f0539bdfe14f6bb5f32896df916bce Reviewed-on: https://go-review.googlesource.com/c/go/+/204657 Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
Ian Lance Taylor authored
The addAdjustedTimers function was a late addition, and it got some of the state machine wrong, leading to failures like https://storage.googleapis.com/go-build-log/930576b6/windows-amd64-2016_53d0319e.log Updates #6239 Updates #27707 Change-Id: I9e94e563b4698ff3035ce609055ca292b9cab3df Reviewed-on: https://go-review.googlesource.com/c/go/+/204280 Run-TryBot: Ian Lance Taylor <iant@golang.org> Reviewed-by:
-
Cuong Manh Le authored
Fixes #35291 Change-Id: I11ae367b6e972cd9e7a22bbc2cb23d32f4d72b98 Reviewed-on: https://go-review.googlesource.com/c/go/+/204617 Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
Audrius Butkevicius authored
Fixes #35222 Change-Id: I8be45092ac4079d21ff54661637a3aa8ec4eb9bc GitHub-Last-Rev: 954a016c9bb749268e97489911ea577a6df9fb4c GitHub-Pull-Request: golang/go#35298 Reviewed-on: https://go-review.googlesource.com/c/go/+/204601 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
- 31 Oct, 2019 11 commits
-
-
Josh Bleecher Snyder authored
And simplify the remaining rules. Updates #30439 Change-Id: Ib89dce16b17ae881824178346ed6ab895b79627e Reviewed-on: https://go-review.googlesource.com/c/go/+/204600 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> Reviewed-by:
-
Andrew Bonventre authored
Change-Id: Ib29e642c56eca96826187f5737d74f8c0430ac3d Reviewed-on: https://go-review.googlesource.com/c/go/+/204638 Run-TryBot: Andrew Bonventre <andybons@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
Dmitri Shuralyov <dmitshur@golang.org> Reviewed-by:
Katie Hockman <katie@golang.org>
-
Andrew Bonventre authored
Change-Id: Ic65a74e56320adbd76aeef1cf3b19d7906ffe8fe Reviewed-on: https://go-review.googlesource.com/c/go/+/204637Reviewed-by:
-
Brad Fitzpatrick authored
Fixes #35280 Change-Id: I6fa3747ff7b92c6fcabdf8692d85e103de55859f Reviewed-on: https://go-review.googlesource.com/c/go/+/204598 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by:
-
Cuong Manh Le authored
If a previous Write returned an error, any subsequent Write or ReadFrom must return that error before any operations. However, only Write behaved correctly and this change fixes that problem by making sure that ReadFrom firstly checks for the underlying error. Fixes #35194 Change-Id: I31356a9e8bd945bc0168b2e3be470f3ae69d4813 Reviewed-on: https://go-review.googlesource.com/c/go/+/204000 Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by:
Emmanuel Odeke <emm.odeke@gmail.com> Reviewed-by:
-
Austin Clements authored
When everything is working correctly, any pointer the garbage collector encounters can only point into a fully initialized heap span, since the span must have been initialized before that pointer could escape the heap allocator and become visible to the GC. However, in various cases, we try to be defensive against bad pointers. In findObject, this is just a sanity check: we never expect to find a bad pointer, but programming errors can lead to them. In spanOfHeap, we don't necessarily trust the pointer and we're trying to check if it really does point to the heap, though it should always point to something. Conservative scanning takes this to a new level, since it can only guess that a word may be a pointer and verify this. In all of these cases, we have a problem that the span lookup and check can race with span initialization, since the span becomes visible to lookups before it's fully initialized. Furthermore, we're about to start initializing the span without the heap lock held, which is going to introduce races where accesses were previously protected by the heap lock. To address this, this CL makes accesses to mspan.state atomic, and ensures that the span is fully initialized before setting the state to mSpanInUse. All loads are now atomic, and in any case where we don't trust the pointer, it first atomically loads the span state and checks that it's mSpanInUse, after which it will have synchronized with span initialization and can safely check the other span fields. For #10958, #24543, but a good fix in general. Change-Id: I518b7c63555b02064b98aa5f802c92b758fef853 Reviewed-on: https://go-review.googlesource.com/c/go/+/203286 Run-TryBot: Austin Clements <austin@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
Austin Clements authored
Currently, several important fields of a heap span are set by heapBits.initSpan, which happens after the span has already been published and returned from the locked region of alloc_m. In particular, allocBits is set very late, which makes mspan.isFree unsafe even if you were to lock the heap because it tries to access allocBits. This CL fixes this by populating these fields in alloc_m. The next CL builds on this to only publish the span once it is fully initialized. Together, they'll make it safe to check allocBits even if there is a race with alloc_m. For #10958, #24543, but a good fix in general. Change-Id: I7fde90023af0f497e826b637efa4d19c32840c08 Reviewed-on: https://go-review.googlesource.com/c/go/+/203285 Run-TryBot: Austin Clements <austin@google.com> Reviewed-by:
-
Cuong Manh Le authored
Updates #35194 Change-Id: Ib854bc6250ddeb606d6ff6240179e23b98e4ac62 Reviewed-on: https://go-review.googlesource.com/c/go/+/203999 Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com> Reviewed-by:
-
Olivier Poitrey authored
Follow the recommandation from RFC 8422, section 5.1.2 of sending back the ec_points_format extension when requested by the client. This is to fix some clients declining the handshake if omitted. Fixes #31943 Change-Id: I7b04dbac6f9af75cda094073defe081e1e9a295d Reviewed-on: https://go-review.googlesource.com/c/go/+/176418 Run-TryBot: Filippo Valsorda <filippo@golang.org> Reviewed-by:
Olivier Poitrey <rs@rhapsodyk.net> Reviewed-by:
-
Daniel Martí authored
This is a re-submission of CL 151157, since it was reverted in CL 190909 due to an introduced crash found by a fuzzer. The revert CL included regression tests, while this CL includes a fixed version of the original change. In particular, what we forgot in the original optimization was that we still need the length and trailing quote checks at the beginning of unquoteBytes. Without those, we could end up in a crash later on. We can work out how many bytes can be unquoted trivially in rescanLiteral, which already iterates over a string's bytes. Removing the extra loop in unquoteBytes simplifies the function and speeds it up, especially when decoding simple strings, which are common. While at it, we can remove the check that s[0]=='"', since all call sites already meet that condition. name old time/op new time/op delta CodeDecoder-8 10.6ms ± 2% 10.5ms ± 1% -1.01% (p=0.004 n=20+10) name old speed new speed delta CodeDecoder-8 183MB/s ± 2% 185MB/s ± 1% +1.02% (p=0.003 n=20+10) Updates #28923. Change-Id: I8c6b13302bcd86a364bc998d72451332c0809cde Reviewed-on: https://go-review.googlesource.com/c/go/+/190659 Run-TryBot: Daniel Martí <mvdan@mvdan.cc> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
Peter Weinberger <pjw@google.com>
-
Michael Munday authored
Add some simple unit tests for these atomic operations. These can't catch all the bugs that are possible with these operations but at least they provide some coverage. Change-Id: I94b9f451fcc9fecdb2a1448c5357b019563ad275 Reviewed-on: https://go-review.googlesource.com/c/go/+/204317 Run-TryBot: Michael Munday <mike.munday@ibm.com> Reviewed-by:
-
- 30 Oct, 2019 7 commits
-
-
Ian Lance Taylor authored
No big changes in the runtime package benchmarks. Changes in the time package benchmarks: name old time/op new time/op delta AfterFunc-12 1.57ms ± 1% 0.07ms ± 1% -95.42% (p=0.000 n=10+8) After-12 1.63ms ± 3% 0.11ms ± 1% -93.54% (p=0.000 n=9+10) Stop-12 78.3µs ± 3% 73.6µs ± 3% -6.01% (p=0.000 n=9+10) SimultaneousAfterFunc-12 138µs ± 1% 111µs ± 1% -19.57% (p=0.000 n=10+9) StartStop-12 28.7µs ± 1% 31.5µs ± 5% +9.64% (p=0.000 n=10+7) Reset-12 6.78µs ± 1% 4.24µs ± 7% -37.45% (p=0.000 n=9+10) Sleep-12 183µs ± 1% 125µs ± 1% -31.67% (p=0.000 n=10+9) Ticker-12 5.40ms ± 2% 0.03ms ± 1% -99.43% (p=0.000 n=10+10) Sub-12 114ns ± 1% 113ns ± 3% ~ (p=0.069 n=9+10) Now-12 37.2ns ± 1% 36.8ns ± 3% ~ (p=0.287 n=8+8) NowUnixNano-12 38.1ns ± 2% 37.4ns ± 3% -1.87% (p=0.020 n=10+9) Format-12 252ns ± 2% 195ns ± 3% -22.61% (p=0.000 n=9+10) FormatNow-12 234ns ± 1% 177ns ± 2% -24.34% (p=0.000 n=10+10) MarshalJSON-12 320ns ± 2% 250ns ± 0% -21.94% (p=0.000 n=8+8) MarshalText-12 320ns ± 2% 245ns ± 2% -23.30% (p=0.000 n=9+10) Parse-12 206ns ± 2% 208ns ± 4% ~ (p=0.084 n=10+10) ParseDuration-12 89.1ns ± 1% 86.6ns ± 3% -2.78% (p=0.000 n=10+10) Hour-12 4.43ns ± 2% 4.46ns ± 1% ~ (p=0.324 n=10+8) Second-12 4.47ns ± 1% 4.40ns ± 3% ~ (p=0.145 n=9+10) Year-12 14.6ns ± 1% 14.7ns ± 2% ~ (p=0.112 n=9+9) Day-12 20.1ns ± 3% 20.2ns ± 1% ~ (p=0.404 n=10+9) Updates #6239 Updates #27707 Change-Id: I51e25a90f941574f1a9cf83a22e84ac8c678537d Reviewed-on: https://go-review.googlesource.com/c/go/+/171883 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
Damien Neil authored
Flush the output log up to the root when a test panics. Prior to this change, only the current test's output log was flushed to its parent, resulting in no output when a subtest panics. For the following test function: func Test(t *testing.T) { for i, test := range []int{1, 0, 2} { t.Run(fmt.Sprintf("%v/%v", i, test), func(t *testing.T) { _ = 1 / test }) } } Output before this change: panic: runtime error: integer divide by zero [recovered] panic: runtime error: integer divide by zero (stack trace follows) Output after this change: --- FAIL: Test (0.00s) --- FAIL: Test/1/0 (0.00s) panic: runtime error: integer divide by zero [recovered] (stack trace follows) Fixes #32121 Change-Id: Ifee07ccc005f0493a902190a8be734943123b6b7 Reviewed-on: https://go-review.googlesource.com/c/go/+/179599 Run-TryBot: Damien Neil <dneil@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: -
Filippo Valsorda authored
Also, fix the alert value sent when a signature by a client certificate is invalid in TLS 1.0-1.2. Fixes #35190 Change-Id: I2ae1d5593dfd5ee2b4d979664aec74aab4a8a704 Reviewed-on: https://go-review.googlesource.com/c/go/+/204157Reviewed-by:
-
Sam Whited authored
The documentation for TokenReader suggests that implementations of the interface may return a token and io.EOF together, indicating that it is the last token in the stream. This is similar to io.Reader. However, if you wrap such a TokenReader in a Decoder it complained about the EOF. A test was added to ensure this behavior on Decoder's. Change-Id: I9083c91d9626180d3bcf5c069a017050f3c7c4a8 Reviewed-on: https://go-review.googlesource.com/c/go/+/130556 Run-TryBot: Sam Whited <sam@samwhited.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
Ian Lance Taylor authored
Updates #6239 Updates #27707 Change-Id: I0a62c1374db485dd830bf02e59625997d9247fc3 Reviewed-on: https://go-review.googlesource.com/c/go/+/203890 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by:
-
Clément Chigot authored
Fcntl can't be called using syscall.Syscall as it doesn't work on AIX. Moreover, fcntl isn't exported by syscall package. However, it can be accessed by exporting it from runtime package using export_aix_test.go. Change-Id: Ib6af66d9d7eacb9ca0525ebc4cd4c92951735f1a Reviewed-on: https://go-review.googlesource.com/c/go/+/204059 Run-TryBot: Ian Lance Taylor <iant@golang.org> Reviewed-by:
-
Clément Chigot authored
Change-Id: I2629711ce02d935130fb2aab29f9028b62ba9fe6 Reviewed-on: https://go-review.googlesource.com/c/go/+/204318 Run-TryBot: Ian Lance Taylor <iant@golang.org> Reviewed-by:
-
