Cannot reproduce the failure locally,
but add explicit test in case some other
machine can.
Fixes#2917 (for now).
R=golang-dev, r
CC=golang-dev
https://golang.org/cl/5651071
Unexports runtime.MemStats and rename MemStatsType to MemStats.
The new accessor requires passing a pointer to a user-allocated
MemStats structure.
Fixes#2572.
R=bradfitz, rsc, bradfitz, gustavo
CC=golang-dev, remy
https://golang.org/cl/5616072
Consequently, remove many package Makefiles,
and shorten the few that remain.
gomake becomes 'go tool make'.
Turn off test phases of run.bash that do not work,
flagged with $BROKEN. Future CLs will restore these,
but this seemed like a big enough CL already.
R=golang-dev, r
CC=golang-dev
https://golang.org/cl/5601057
The implementation is similar to the one from the double-conversion
library used in the Chrome V8 engine.
old ns/op new ns/op speedup
BenchmarkAppendFloatDecimal 591 480 1.2x
BenchmarkAppendFloat 2956 486 6.1x
BenchmarkAppendFloatExp 10622 503 21.1x
BenchmarkAppendFloatNegExp 40343 483 83.5x
BenchmarkAppendFloatBig 2798 664 4.2x
See F. Loitsch, ``Printing Floating-Point Numbers Quickly and
Accurately with Integers'', Proceedings of the ACM, 2010.
R=rsc
CC=golang-dev, remy
https://golang.org/cl/5502079
is consistent with what the Go compiler returns when such sequences
appear in string literals.
Fixes#2658.
R=golang-dev, rsc, r, r, nigeltao
CC=golang-dev
https://golang.org/cl/5530051
A test intended for denormals erroneously returned true also for
infinities, leading to bad overflows and wrong error estimates.
R=rsc
CC=golang-dev, remy
https://golang.org/cl/5489091
The algorithm is the same as in the double-conversion library
which also implements Florian Loitsch's fast printing algorithm.
It uses extended floats with a 64-bit mantissa, but cannot give
an answer for all cases.
old ns/op new ns/op speedup
BenchmarkAtof64Decimal 332 322 1.0x
BenchmarkAtof64Float 385 373 1.0x
BenchmarkAtof64FloatExp 9777 419 23.3x
BenchmarkAtof64Big 3934 691 5.7x
BenchmarkAtof64RandomBits 34060 899 37.9x
BenchmarkAtof64RandomFloats 1329 680 2.0x
See F. Loitsch, ``Printing Floating-Point Numbers Quickly and
Accurately with Integers'', Proceedings of the ACM, 2010.
R=ality, rsc
CC=golang-dev, remy
https://golang.org/cl/5494068
The longest numbers we have to represent are the smallest denormals.
Their decimal mantissa is not longer than 5^1100. Taking into
account some extra size for in-place operations, 800 digits are
enough. This saves time used for zero intiialization of extra
bytes.
old ns/op new ns/op delta
strconv_test.BenchmarkAtof64Decimal 521 334 -35.9%
strconv_test.BenchmarkAtof64Float 572 391 -31.6%
strconv_test.BenchmarkAtof64FloatExp 10242 10036 -2.0%
strconv_test.BenchmarkAtof64Big 4229 4029 -4.7%
strconv_test.BenchmarkFormatFloatDecimal 1396 934 -33.1%
strconv_test.BenchmarkFormatFloat 4295 3341 -22.2%
strconv_test.BenchmarkFormatFloatExp 12035 11181 -7.1%
strconv_test.BenchmarkFormatFloatBig 4213 3229 -23.4%
strconv_test.BenchmarkAppendFloatDecimal 1031 600 -41.8%
strconv_test.BenchmarkAppendFloat 3971 3044 -23.3%
strconv_test.BenchmarkAppendFloatExp 11699 11003 -5.9%
strconv_test.BenchmarkAppendFloatBig 3836 2915 -24.0%
R=golang-dev, bradfitz, rsc
CC=golang-dev, remy
https://golang.org/cl/5491064
(Note that the Int and Uint benchmarks use different test sets
and thus cannot be compared against each other. Int and Uint
conversions are approximately the same speed).
Before (best of 3 runs):
strconv_test.BenchmarkFormatInt 100000 15636 ns/op
strconv_test.BenchmarkAppendInt 100000 18930 ns/op
strconv_test.BenchmarkFormatUint 500000 4392 ns/op
strconv_test.BenchmarkAppendUint 500000 5152 ns/op
After (best of 3 runs):
strconv_test.BenchmarkFormatInt 200000 10070 ns/op (-36%)
strconv_test.BenchmarkAppendInt 200000 7097 ns/op (-63%)
strconv_test.BenchmarkFormatUint 1000000 2893 ns/op (-34%)
strconv_test.BenchmarkAppendUint 500000 2462 ns/op (-52%)
R=r, rsc, r
CC=golang-dev
https://golang.org/cl/5449093
I found these by adding a check to govet, but the check
produces far too many false positives to be useful.
Even so, these few seem worth cleaning up.
R=golang-dev, bradfitz, iant
CC=golang-dev
https://golang.org/cl/5311067
This makes decimal a good test
case for the escape analysis.
With escape analysis:
benchmark old ns/op new ns/op delta
BenchmarkAtof64Decimal 1954 243 -87.56%
BenchmarkAtof64Float 2008 293 -85.41%
BenchmarkAtof64FloatExp 10106 8814 -12.78%
BenchmarkAtof64Big 5113 3486 -31.82%
R=golang-dev, gri
CC=golang-dev
https://golang.org/cl/4861042
This is the form as returned by Postgres, as well
as JavaScript.
I've tried and failed to find authorative docs online
about the proper string serialization, if any.
R=golang-dev, gri, r, r, rsc
CC=golang-dev
https://golang.org/cl/4650077
Change the signature of Split to have no count,
assuming a full split, and rename the existing
Split with a count to SplitN.
Do the same to package bytes.
Add a gofix module.
R=adg, dsymonds, alex.brainman, rsc
CC=golang-dev
https://golang.org/cl/4661051
This is a core API change.
1) gofix misc src
2) Manual adjustments to the following files under src/pkg:
gob/decode.go
rpc/client.go
os/error.go
io/io.go
bufio/bufio.go
http/request.go
websocket/client.go
as well as:
src/cmd/gofix/testdata/*.go.in (reverted)
test/fixedbugs/bug243.go
3) Implemented gofix patch (oserrorstring.go) and test case (oserrorstring_test.go)
Compiles and runs all tests.
R=r, rsc, gri
CC=golang-dev
https://golang.org/cl/4607052
add QuoteToASCII.
The Quote and QuoteRune functions now let printable
runes (as defined by unicode.IsPrint) through. When
true 7-bit clean stuff is necessary, there are now two
new functions: QuoteToASCII and QuoteRuneToASCII.
Printf("%q") uses Quote. To get the old behavior, it
will now be necessary to say
Printf("%s", strconv.QuoteToASCII(s))
but that should rarely be necessary.
R=golang-dev, gri, r
CC=golang-dev
https://golang.org/cl/4561061
We replace the current Open with:
OpenFile(name, flag, perm) // same as old Open
Open(name) // same as old Open(name, O_RDONLY, 0)
Create(name) // same as old Open(name, O_RDWR|O_TRUNC|O_CREAT, 0666)
This CL includes a gofix module and full code updates: all.bash passes.
(There may be a few comments I missed.)
The interesting packages are:
gofix
os
Everything else is automatically generated except for hand tweaks to:
src/pkg/io/ioutil/ioutil.go
src/pkg/io/ioutil/tempfile.go
src/pkg/crypto/tls/generate_cert.go
src/cmd/goyacc/goyacc.go
src/cmd/goyacc/units.y
R=golang-dev, bradfitzwork, rsc, r2
CC=golang-dev
https://golang.org/cl/4357052
