runtime: move comment about address space sizes to malloc.go

Currently there's a detailed comment in lfstack_64bit.go about address
space limitations on various architectures. Since that's now relevant
to malloc, move it to a more prominent place in the documentation for
memLimitBits.

Updates #10460.

Change-Id: If9708291cf3a288057b8b3ba0ba6a59e3602bbd6
Reviewed-on: https://go-review.googlesource.com/85889
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Rick Hudson <rlh@golang.org>

diff --git a/src/runtime/lfstack_64bit.go b/src/runtime/lfstack_64bit.go
index cf6c02895fdae6b9b514e65d30b860bf55f443ec..19d80452034906c933591efa27479fea0de92cba 100644 (file)
--- a/src/runtime/lfstack_64bit.go
+++ b/src/runtime/lfstack_64bit.go
@@ -11,30 +11,17 @@ import "unsafe"
 const (
        // addrBits is the number of bits needed to represent a virtual address.
        //
-       // In Linux the user address space for each architecture is limited as
-       // follows (taken from the processor.h file for the architecture):
-       //
-       // Architecture  Name              Maximum Value (exclusive)
-       // ---------------------------------------------------------------------
-       // amd64         TASK_SIZE_MAX     0x007ffffffff000 (47 bit addresses)
-       // arm64         TASK_SIZE_64      0x01000000000000 (48 bit addresses)
-       // ppc64{,le}    TASK_SIZE_USER64  0x00400000000000 (46 bit addresses)
-       // mips64{,le}   TASK_SIZE64       0x00010000000000 (40 bit addresses)
-       // s390x         TASK_SIZE         1<<64 (64 bit addresses)
-       //
-       // These values may increase over time. In particular, ppc64
-       // and mips64 support arbitrary 64-bit addresses in hardware,
-       // but Linux imposes the above limits. amd64 has hardware
-       // support for 57 bit addresses as of 2017 (56 bits for user
-       // space), but Linux only uses addresses above 1<<47 for
-       // mappings that explicitly pass a high hint address.
+       // See memLimitBits for a table of address space sizes on
+       // various architectures. 48 bits is enough for all
+       // architectures except s390x.
        //
        // On AMD64, virtual addresses are 48-bit (or 57-bit) numbers sign extended to 64.
        // We shift the address left 16 to eliminate the sign extended part and make
        // room in the bottom for the count.
        //
-       // On s390x, there's not much we can do, so we just hope that
-       // the kernel doesn't get to really high addresses.
+       // On s390x, virtual addresses are 64-bit. There's not much we
+       // can do about this, so we just hope that the kernel doesn't
+       // get to really high addresses and panic if it does.
        addrBits = 48
 
        // In addition to the 16 bits taken from the top, we can take 3 from the

diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index a397382291c7b49c98d1abd4ab113885c274b1bd..f3e738116cb7b78086ec4bd393fa088a4105125b 100644 (file)
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -160,7 +160,24 @@ const (
        //
        // On 64-bit platforms, we limit this to 48 bits because that
        // is the maximum supported by Linux across all 64-bit
-       // architectures, with the exception of s390x.
+       // architectures, with the exception of s390x. Based on
+       // processor.h:
+       //
+       // Architecture  Name              Maximum Value (exclusive)
+       // ---------------------------------------------------------------------
+       // amd64         TASK_SIZE_MAX     0x007ffffffff000 (47 bit addresses)
+       // arm64         TASK_SIZE_64      0x01000000000000 (48 bit addresses)
+       // ppc64{,le}    TASK_SIZE_USER64  0x00400000000000 (46 bit addresses)
+       // mips64{,le}   TASK_SIZE64       0x00010000000000 (40 bit addresses)
+       // s390x         TASK_SIZE         1<<64 (64 bit addresses)
+       //
+       // These values may increase over time. In particular, ppc64
+       // and mips64 support arbitrary 64-bit addresses in hardware,
+       // but Linux imposes the above limits. amd64 has hardware
+       // support for 57 bit addresses as of 2017 (56 bits for user
+       // space), but Linux only uses addresses above 1<<47 for
+       // mappings that explicitly pass a high hint address.
+       //
        // s390x supports full 64-bit addresses, but the allocator
        // will panic in the unlikely event we exceed 48 bits.
        //