The latest Go release, version 1.3, arrives six months after 1.2,and contains no language changes.It focuses primarily on implementation work, providingprecise garbage collection,a major refactoring of the compiler toolchain that results infaster builds, especially for large projects,significant performance improvements across the board,and support for DragonFly BSD, Solaris, Plan 9 and Google’s Native Client architecture (NaCl).It also has an important refinement to the memory model regarding synchronization.As always, Go 1.3 keeps thepromiseof compatibility,and almost everythingwill continue to compile and run without change when moved to 1.3.

Changes to the supported operating systems and architectures

Removal of support for Windows 2000

Microsoft stopped supporting Windows 2000 in 2010.Since it hasimplementation difficultiesregarding exception handling (signals in Unix terminology),as of Go 1.3 it is not supported by Go either.

Support for DragonFly BSD

Go 1.3 now includes experimental support for DragonFly BSD on theamd64 (64-bit x86) and386 (32-bit x86) architectures.It uses DragonFly BSD 3.6 or above.

Support for FreeBSD

It was not announced at the time, but since the release of Go 1.2, support for Go on FreeBSDrequires FreeBSD 8 or above.

As of Go 1.3, support for Go on FreeBSD requires that the kernel be compiled with theCOMPAT_FREEBSD32 flag configured.

In concert with the switch to EABI syscalls for ARM platforms, Go 1.3 will run only on FreeBSD 10.The x86 platforms, 386 and amd64, are unaffected.

Support for Native Client

Support for the Native Client virtual machine architecture has returned to Go with the 1.3 release.It runs on the 32-bit Intel architectures (GOARCH=386) and also on 64-bit Intel, but using32-bit pointers (GOARCH=amd64p32).There is not yet support for Native Client on ARM.Note that this is Native Client (NaCl), not Portable Native Client (PNaCl).Details about Native Client arehere;how to set up the Go version is describedhere.

Support for NetBSD

As of Go 1.3, support for Go on NetBSD requires NetBSD 6.0 or above.

Support for OpenBSD

As of Go 1.3, support for Go on OpenBSD requires OpenBSD 5.5 or above.

Support for Plan 9

Go 1.3 now includes experimental support for Plan 9 on the386 (32-bit x86) architecture.It requires theTsemacquire syscall, which has been in Plan 9 since June, 2012.

Support for Solaris

Go 1.3 now includes experimental support for Solaris on theamd64 (64-bit x86) architecture.It requires illumos, Solaris 11 or above.

Changes to the memory model

The Go 1.3 memory modeladds a new ruleconcerning sending and receiving on buffered channels,to make explicit that a buffered channel can be used as a simplesemaphore, using a send into thechannel to acquire and a receive from the channel to release.This is not a language change, just a clarification about an expected property of communication.

Changes to the implementations and tools

Stack

Go 1.3 has changed the implementation of goroutine stacks away from the old,“segmented” model to a contiguous model.When a goroutine needs more stackthan is available, its stack is transferred to a larger single block of memory.The overhead of this transfer operation amortizes well and eliminates the old “hot spot”problem when a calculation repeatedly steps across a segment boundary.Details including performance numbers are in thisdesign document.

Changes to the garbage collector

For a while now, the garbage collector has beenprecise when examiningvalues in the heap; the Go 1.3 release adds equivalent precision to values on the stack.This means that a non-pointer Go value such as an integer will never be mistaken for apointer and prevent unused memory from being reclaimed.

Starting with Go 1.3, the runtime assumes that values with pointer typecontain pointers and other values do not.This assumption is fundamental to the precise behavior of both stack expansionand garbage collection.Programs that usepackage unsafeto store integers in pointer-typed values are illegal and will crash if the runtime detects the behavior.Programs that usepackage unsafe to store pointersin integer-typed values are also illegal but more difficult to diagnose during execution.Because the pointers are hidden from the runtime, a stack expansion or garbage collectionmay reclaim the memory they point at, creatingdangling pointers.

Updating: Code that usesunsafe.Pointer to convertan integer-typed value held in memory into a pointer is illegal and must be rewritten.Such code can be identified bygo vet.

Map iteration

Iterations over small maps no longer happen in a consistent order.Go 1 defines that “The iteration order over mapsis not specified and is not guaranteed to be the same from one iteration to the next.”To keep code from depending on map iteration order,Go 1.0 started each map iteration at a random index in the map.A new map implementation introduced in Go 1.1 neglected to randomizeiteration for maps with eight or fewer entries, although the iteration ordercan still vary from system to system.This has allowed people to write Go 1.1 and Go 1.2 programs thatdepend on small map iteration order and therefore only work reliably on certain systems.Go 1.3 reintroduces random iteration for small maps in order to flush out these bugs.

Updating: If code assumes a fixed iteration order for small maps,it will break and must be rewritten not to make that assumption.Because only small maps are affected, the problem arises most often in tests.

The linker

As part of the generaloverhaul tothe Go linker, the compilers and linkers have been refactored.The linker is still a C program, but now the instruction selection phase thatwas part of the linker has been moved to the compiler through the creation of a newlibrary calledliblink.By doing instruction selection only once, when the package is first compiled,this can speed up compilation of large projects significantly.

Updating: Although this is a major internal change, it should have noeffect on programs.

Status of gccgo

GCC release 4.9 will contain the Go 1.2 (not 1.3) version of gccgo.The release schedules for the GCC and Go projects do not coincide,which means that 1.3 will be available in the development branch butthat the next GCC release, 4.10, will likely have the Go 1.4 version of gccgo.

Changes to the go command

Thecmd/go command has several newfeatures.Thego run andgo test subcommandssupport a new-exec option to specify an alternateway to run the resulting binary.Its immediate purpose is to support NaCl.

The test coverage support of thego testsubcommand now automatically sets the coverage mode to-atomicwhen the race detector is enabled, to eliminate false reports about unsafeaccess to coverage counters.

Thego test subcommandnow always builds the package, even if it has no test files.Previously, it would do nothing if no test files were present.

Thego build subcommandsupports a new-i option to install dependenciesof the specified target, but not the target itself.

Cross compiling withcgo enabledis now supported.The CC_FOR_TARGET and CXX_FOR_TARGET environmentvariables are used when running all.bash to specify the cross compilersfor C and C++ code, respectively.

Finally, the go command now supports packages that import Objective-Cfiles (suffixed.m) through cgo.

Changes to cgo

Thecmd/cgo command,which processesimport "C" declarations in Go packages,has corrected a serious bug that may cause some packages to stop compiling.Previously, all pointers to incomplete struct types translated to the Go type*[0]byte,with the effect that the Go compiler could not diagnose passing one kind of struct pointerto a function expecting another.Go 1.3 corrects this mistake by translating each differentincomplete struct to a different named type.

Given the C declarationtypedef struct S T for an incompletestruct S,some Go code used this bug to refer to the typesC.struct_S andC.T interchangeably.Cgo now explicitly allows this use, even for completed struct types.However, some Go code also used this bug to pass (for example) a*C.FILEfrom one package to another.This is not legal and no longer works: in general Go packagesshould avoid exposing C types and names in their APIs.

Updating: Code confusing pointers to incomplete types orpassing them across package boundaries will no longer compileand must be rewritten.If the conversion is correct and must be preserved,use an explicit conversion viaunsafe.Pointer.

SWIG 3.0 required for programs that use SWIG

For Go programs that use SWIG, SWIG version 3.0 is now required.Thecmd/go command will now link theSWIG generated object files directly into the binary, rather thanbuilding and linking with a shared library.

Command-line flag parsing

In the gc toolchain, the assemblers now use thesame command-line flag parsing rules as the Go flag package, a departurefrom the traditional Unix flag parsing.This may affect scripts that invoke the tool directly.For example,go tool 6a -SDfoo must now be writtengo tool 6a -S -D foo.(The same change was made to the compilers and linkers inGo 1.1.)

Changes to godoc

When invoked with the-analysis flag,godocnow performs sophisticated static analysis of the code it indexes.The results of analysis are presented in both the source view and thepackage documentation view, and include the call graph of each packageand the relationships betweendefinitions and references,types and their methods,interfaces and their implementations,send and receive operations on channels,functions and their callers, andcall sites and their callees.

Miscellany

The programmisc/benchcmp that comparesperformance across benchmarking runs has been rewritten.Once a shell and awk script in the main repository, it is now a Go program in thego.tools repo.Documentation ishere.

For the few of us that build Go distributions, the toolmisc/dist has beenmoved and renamed; it now lives inmisc/makerelease, still in the main repository.

Performance

The performance of Go binaries for this release has improved in many cases due to changesin the runtime and garbage collection, plus some changes to libraries.Significant instances include:

• The runtime handles defers more efficiently, reducing the memory footprint by about two kilobytesper goroutine that calls defer.
• The garbage collector has been sped up, using a concurrent sweep algorithm,better parallelization, and larger pages.The cumulative effect can be a 50-70% reduction in collector pause time.
• The race detector (seethis guide)is now about 40% faster.
• The regular expression packageregexpis now significantly faster for certain simple expressions due to the implementation ofa second, one-pass execution engine.The choice of which engine to use is automatic;the details are hidden from the user.

Also, the runtime now includes in stack dumps how long a goroutine has been blocked,which can be useful information when debugging deadlocks or performance issues.

Changes to the standard library

New packages

A new packagedebug/plan9obj was added to the standard library.It implements access to Plan 9a.out object files.

Major changes to the library

A previous bug incrypto/tlsmade it possible to skip verification in TLS inadvertently.In Go 1.3, the bug is fixed: one must specify either ServerName orInsecureSkipVerify, and if ServerName is specified it is enforced.This may break existing code that incorrectly depended on insecurebehavior.

There is an important new type added to the standard library:sync.Pool.It provides an efficient mechanism for implementing certain types of caches whose memorycan be reclaimed automatically by the system.

Thetesting package’s benchmarking helper,B, now has aRunParallel methodto make it easier to run benchmarks that exercise multiple CPUs.

Updating: The crypto/tls fix may break existing code, but suchcode was erroneous and should be updated.

Minor changes to the library

The following list summarizes a number of minor changes to the library, mostly additions.See the relevant package documentation for more information about each change.

• In thecrypto/tls package,a newDialWithDialerfunction lets one establish a TLS connection using an existing dialer, making it easierto control dial options such as timeouts.The package also now reports the TLS version used by the connection in theConnectionStatestruct.
• TheCreateCertificatefunction of thecrypto/tls packagenow supports parsing (and elsewhere, serialization) of PKCS #10 certificatesignature requests.
• The formatted print functions of thefmt package now define%Fas a synonym for%f when printing floating-point values.
• Themath/big package’sInt andRat typesnow implementencoding.TextMarshaler andencoding.TextUnmarshaler.
• The complex power function,Pow,now specifies the behavior when the first argument is zero.It was undefined before.The details are in thedocumentation for the function.
• Thenet/http package now exposes theproperties of a TLS connection used to make a client request in the newResponse.TLS field.
• Thenet/http package nowallows setting an optional server error loggerwithServer.ErrorLog.The default is still that all errors go to stderr.
• Thenet/http package nowsupports disabling HTTP keep-alive connections on the serverwithServer.SetKeepAlivesEnabled.The default continues to be that the server does keep-alive (reusesconnections for multiple requests) by default.Only resource-constrained servers or those in the process of gracefulshutdown will want to disable them.
• Thenet/http package adds an optionalTransport.TLSHandshakeTimeoutsetting to cap the amount of time HTTP client requests will wait forTLS handshakes to complete.It’s now also set by defaultonDefaultTransport.
• Thenet/http package’sDefaultTransport,used by the HTTP client code, nowenablesTCPkeep-alives by default.OtherTransportvalues with a nilDial field continue to function the sameas before: no TCP keep-alives are used.
• Thenet/http packagenow enablesTCPkeep-alives for incoming server requests whenListenAndServeorListenAndServeTLSare used.When a server is started otherwise, TCP keep-alives are not enabled.
• Thenet/http package nowprovides anoptionalServer.ConnStatecallback to hook various phases of a server connection’s lifecycle(seeConnState).This can be used to implement rate limiting or graceful shutdown.
• Thenet/http package’s HTTPclient now has anoptionalClient.Timeoutfield to specify an end-to-end timeout on requests made using theclient.
• Thenet/http package’sRequest.ParseMultipartFormmethod will now return an error if the body’sContent-Typeis notmultipart/form-data.Prior to Go 1.3 it would silently fail and returnnil.Code that relies on the previous behavior should be updated.
• In thenet package,theDialer struct nowhas aKeepAlive option to specify a keep-alive period for the connection.
• Thenet/http package’sTransportnow closesRequest.Bodyconsistently, even on error.
• Theos/exec package now implementswhat the documentation has always said with regard to relative paths for the binary.In particular, it only callsLookPathwhen the binary’s file name contains no path separators.
• TheSetMapIndexfunction in thereflect packageno longer panics when deleting from anil map.
• If the main goroutine callsruntime.Goexitand all other goroutines finish execution, the program now always crashes,reporting a detected deadlock.Earlier versions of Go handled this situation inconsistently: most instanceswere reported as deadlocks, but some trivial cases exited cleanly instead.
• The runtime/debug package now has a new functiondebug.WriteHeapDumpthat writes out a description of the heap.
• TheCanBackquotefunction in thestrconv packagenow considers theDEL character,U+007F, to benon-printing.
• Thesyscall package now providesSendmsgNas an alternate version ofSendmsgthat returns the number of bytes written.
• On Windows, thesyscall package nowsupports the cdecl calling convention through the addition of a new functionNewCallbackCDeclalongside the existing functionNewCallback.
• Thetesting package nowdiagnoses tests that callpanic(nil), which are almost always erroneous.Also, tests now write profiles (if invoked with profiling flags) even on failure.
• Theunicode package and associatedsupport throughout the system has been upgraded fromUnicode 6.2.0 toUnicode 6.3.0.