code review 164090044: doc/go1.4.html: runtime and performance

doc/go1.4.html

 <!--{
         "Title": "Go 1.4 Release Notes",
         "Path":  "/doc/go1.4",
         "Template": true
 }-->
 
 <h2 id="introduction">Introduction to Go 1.4</h2>
 
 <p>
 The latest Go release, version 1.4, arrives as scheduled six months after 1.3
@@ skipping 69 matching lines @@
 </p>
 
 <h2 id="os">Changes to the supported operating systems and architectures</h2>
 
 <h3 id="foobarblatz">FooBarBlatz</h3>
 
 <p>
 TODO news about foobarblatz
 </p>
 
+<h2 id="runtime">Changes to the runtime</h2>
+
+<p>
+Up to Go 1.4, the runtime (garbage collector, concurrency support, interface management,
+maps, slices, strings, ...) was mostly written in C, with some assembler support.
+In 1.4, much of the code has been translated to Go so that the garbage collector can scan
+the stacks of programs in the runtime and get accurate information about what variables
+are active.
+This change was large but should have no semantic effect on programs.
+</p>
+
+<p>
+This rewrite allows the garbage collector in 1.4 to be fully precise,
+meaning that it is aware of the location of all active pointers in the program.
+This means the heap will be smaller as there will be no false positives keeping non-pointers alive.
+Other related changes also reduce the heap size, which is smaller by 10%-30% overall
+relative to the previous release.
+</p>
+
+<p>
+A consequence is that stacks are no longer segmented, eliminating the "hot split" problem.

[adg1, 2014/10/28 01:04:07]

This already changed in 1.3.
http://golang.org/doc/go1.3#stacks

+When a stack limit is reached, a new, larger stack is allocated, all active frames for
+the goroutine are copied there, and any pointers into that stack can be updated.
+Performance can be noticeably better in some cases and always more predictable.
+Details are available in <a href="/s/contigstacks">the design document</a>.
+</p>
+
+<p>
+The use of contiguous stacks mean that stacks can start smaller without triggering performance issues,
+so the default starting size for a goroutine's stack in 1.4 has been reduced to 2048 bytes from 8192 bytes.
+TODO: It may be bumped to 4096 for the release.
+</p>
+
+<p>
+As preparation for the concurrent garbage collector scheduled for the 1.5 release,
+writes to pointer values in the heap are now done by a function call,
+called a write barrier, rather than directly from the function updating the value.
+In this next release, this will permit the garbage collector to mediate writes to the heap while it is running.
+This change has no semantic effect on programs in 1.4, but was
+included in the release to test the compiler and the resulting performance.
+</p>
+
+<p>
+The implementation of interface values has been modified.
+In earlier releases, the interface contained a word that was either a pointer or a one-word
+scalar value, depending on the type of the concrete object stored.
+This implementation was problematical for the garbage collector,
+so as of 1.4 interface values always hold a pointer.
+In running programs, most interface values were pointers anyway,
+so the effect is minimal, but programs store integers (for example) in
+interfaces will see more allocations.
+</p>
+
 <h2 id="compatibility">Changes to the compatibility guidelines</h2>
 
 <p>
 The <a href="/pkg/unsafe/"><code>unsafe</code></a> package allows one
 to defeat Go's type system by exploiting internal details of the implementation
 or machine representation of data.
 It was never explicitly specified what use of <code>unsafe</code> meant
 with respect to compatibility as specified in the
 <a href="go1compat.html">Go compatibilty guidelines</a>.
 The answer, of course, is that we can make no promise of compatibility
@@ skipping 70 matching lines @@
 
 <h3 id="misc">Miscellany</h3>
 
 <p>
 TODO misc news
 </p>
 
 <h2 id="performance">Performance</h2>
 
 <p>
-TODO performance news
+Most programs will run about the same speed or slightly faster in 1.4 than in 1.3;
+some will be slightly slower.
+There are many changes, making it hard to be precise about what to expect.
+</p>
+
+<p>
+As mentioned above, much of the runtime was translated to Go from C,
+which led to some reduction in heap sizes.
+It also improved performance slightly because the Go compiler is better
+at optimization, due to things like inlining, than the C compiler used to build
+the runtime.
+</p>
+
+<p>
+The garbage collector was sped up, leading to measurable improvements for
+garbage-heavy programs.
+On the other hand, the new write barriers slow things down again, typically
+by about the same amount but, depending on their behavior, some programs
+may be somewhat slower or faster.
+</p>
+
+<p>
+Library changes that affect performance are documented below.
 </p>
 
 <h2 id="library">Changes to the standard library</h2>
 
 <h3 id="new_packages">New packages</h3>
 
 <p>
 TODO new packages
 </p>
 
@@ skipping 11 matching lines @@
 </p>
 
 <ul>
 
 <li> TODO changes
 </li>
 </ul>
 
 <pre>
 
-the directory src/pkg has been deleted, for instance src/pkg/fmt is now just src/fmt (CL 134570043)
-
 cmd/6l, liblink: use pc-relative addressing for all memory references, so that linking Go binaries at high addresses works (CL 125140043). This cuts the maximum size of a Go binary's text+data+bss from 4GB to 2GB.
 cmd/go: import comments (CL 124940043)
 cmd/go: implement "internal" (CL 120600043)
 cmd/go: implement "generate" (CL 125580044)
 cmd/go: disallow C sources except when using cgo (CL 149720043)
 cmd/go: add test -o flag (CL 149070043)
 cmd/go: redefine build -a to skip standard library in releases (CL 151730045)
 cmd/go: compile and link all _test.go files during 'go test', even in packages where there are no Test functions (CL 150980043)
 cmd/go: (via go/build): a GOOS prefix acts as a tag only if preceded by an underscore. this is a breaking change. (CL 147690043)
 
 asm: make textflag.h available outside of cmd/ld (CL 128050043)
 bufio: handling of empty tokens at EOF changed, may require scanner change (CL 145390043)
 compress/flate, compress/gzip, compress/zlib: Reset support (https://codereview.appspot.com/97140043)
 crypto/tls: add support for ALPN (RFC 7301) (CL 108710046)
 crypto/tls: support programmatic selection of server certificates (CL 107400043)
 encoding/asn1: optional elements with a default value will now only be omitted if they have that value (CL 86960045)
 flag: it is now an error to set a flag multiple times (CL 156390043)
 fmt: print type *map[T]T as &amp;map[k:v] (CL 154870043)
 encoding/csv: do not quote empty strings, quote \. (CL 164760043)
 encoding/gob: remove unsafe (CL 102680045)
 misc: deleted editor support; refer to https://code.google.com/p/go-wiki/wiki/IDEsAndTextEditorPlugins instead (CL 105470043)
 net/http: add Request.BasicAuth method (CL 76540043)
 net/http: add Transport.DialTLS hook (CL 137940043)
 net/http/httputil: add ReverseProxy.ErrorLog (CL 132750043)
 os: implement symlink support for windows (CL 86160044)
 reflect: add type.Comparable (CL 144020043)
+reflect: Value is one word smaller
 runtime: implement monotonic clocks on windows (CL 108700045)
-runtime: memory consumption is reduced by 10-30% (CL 106260045 removes type info from heap, CL 145790043 reduces stack size to 2K (4K on plan 9 and windows))
 runtime: MemStats.Mallocs now counts very small allocations missed in Go 1.3. This may break tests using runtime.ReadMemStats or testing.AllocsPerRun by giving a more accurate answer than Go 1.3 did (CL 143150043).
 runtime/race: freebsd is supported (CL 107270043)
 swig: Due to runtime changes Go 1.4 will require SWIG 3.0.3 (not yet released)
 sync/atomic: add Value (CL 136710045)
 syscall: Setuid, Setgid are disabled on linux platforms. On linux those syscalls operate on the calling thread, not the whole process. This does not match the semantics of other platforms, nor the expectations of the caller, so the operations have been disabled until issue 1435 is resolved (CL 106170043)
 syscall: now frozen (CL 129820043)
 testing: add Coverage (CL 98150043)
 testing: add TestMain support (CL 148770043)
 text/scanner: add IsIdentRune field of Scanner. (CL 108030044)
 text/template: allow comparison of signed and unsigned integers (CL 149780043)
 time: use the micro symbol (µ (U+00B5)) to print microsecond duration (CL 105030046)
 unsafe: document the existing situation that unsafe programs are not go1-guaranteed (CL 162060043)
 
 go.sys subrepo created: http://golang.org/s/go1.4-syscall
 </pre>