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

[dev.cc] runtime: allow more address bits in lfstack on Power64

Browse Source 
Previously, lfstack assumed Linux limited user space addresses
to 43 bits on Power64 based on a paper from 2001.  It turns
out the limit is now 46 bits, so lfstack was truncating
pointers.

Raise the limit to 48 bits (for some future proofing and to
make it match amd64) and add a self-test that will fail in a
useful way if ever unpack(pack(x)) != x.

With this change, dev.cc passes all.bash on power64le.

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/174430043
This commit is contained in:
Austin Clements 2014-11-19 11:30:58 -05:00
parent b27c0618eb
commit b76e836042
2 changed files with 17 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/runtime/lfstack.go
View File

@ -12,6 +12,10 @@ import "unsafe"
func lfstackpush(head *uint64, node *lfnode) {
node.pushcnt++
new := lfstackPack(node, node.pushcnt)
if node1, _ := lfstackUnpack(new); node1 != node {
println("runtime: lfstackpush invalid packing: node=", node, " cnt=", hex(node.pushcnt), " packed=", hex(new), " -> node=", node1, "\n")
gothrow("lfstackpush")
}
for {
old := atomicload64(head)
node.next, _ = lfstackUnpack(old)

20
src/runtime/lfstack_linux_power64x.go
View File

@ -9,18 +9,24 @@ package runtime
import "unsafe"
// On Power64, Linux limits the user address space to 43 bits.
// (https://www.kernel.org/doc/ols/2001/ppc64.pdf)
// In addition to the 21 bits taken from the top, we can take 3 from the
// bottom, because node must be pointer-aligned, giving a total of 24 bits
// On Power64, Linux limits the user address space to 46 bits (see
// TASK_SIZE_USER64 in the Linux kernel). This has grown over time,
// so here we allow 48 bit addresses.
//
// In addition to the 16 bits taken from the top, we can take 3 from the
// bottom, because node must be pointer-aligned, giving a total of 19 bits
// of count.
const (
addrBits = 48
cntBits = 64 - addrBits + 3
)
func lfstackPack(node *lfnode, cnt uintptr) uint64 {
return uint64(uintptr(unsafe.Pointer(node)))<<21 | uint64(cnt&(1<<24-1))
return uint64(uintptr(unsafe.Pointer(node)))<<(64-addrBits) | uint64(cnt&(1<<cntBits-1))
}
func lfstackUnpack(val uint64) (node *lfnode, cnt uintptr) {
node = (*lfnode)(unsafe.Pointer(uintptr(val >> 24 << 3)))
cnt = uintptr(val & (1<<24 - 1))
node = (*lfnode)(unsafe.Pointer(uintptr(val >> cntBits << 3)))
cnt = uintptr(val & (1<<cntBits - 1))
return
}