qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-23 19:00:04 -07:00
Code Releases Activity

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

Browse Source 
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>
This commit is contained in:
Austin Clements 2018-01-01 17:53:59 -05:00
parent 51ae88ee2f
commit 90666b8a3d
2 changed files with 24 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/runtime/lfstack_64bit.go
View File

@ -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

19
src/runtime/malloc.go
View File

@ -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.
//