110 lines
3.6 KiB
Go
110 lines
3.6 KiB
Go
// Copyright 2019 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
//go:build 386 || arm || mips || mipsle || wasm || (ios && arm64) || amd64p32 || armbe || m68k || mips64p32 || mips64p32le || nios2 || ppc || riscv || s390 || sh || shbe || sparc
|
|
|
|
// wasm is a treated as a 32-bit architecture for the purposes of the page
|
|
// allocator, even though it has 64-bit pointers. This is because any wasm
|
|
// pointer always has its top 32 bits as zero, so the effective heap address
|
|
// space is only 2^32 bytes in size (see heapAddrBits).
|
|
|
|
package runtime
|
|
|
|
import "unsafe"
|
|
|
|
const (
|
|
// The number of levels in the radix tree.
|
|
summaryLevels = 4
|
|
|
|
// Constants for testing.
|
|
pageAlloc32Bit = 1
|
|
pageAlloc64Bit = 0
|
|
|
|
// Number of bits needed to represent all indices into the L1 of the
|
|
// chunks map.
|
|
//
|
|
// See (*pageAlloc).chunks for more details. Update the documentation
|
|
// there should this number change.
|
|
pallocChunksL1Bits = 0
|
|
)
|
|
|
|
// See comment in mpagealloc_64bit.go.
|
|
var levelBits = [summaryLevels]uint{
|
|
summaryL0Bits,
|
|
summaryLevelBits,
|
|
summaryLevelBits,
|
|
summaryLevelBits,
|
|
}
|
|
|
|
// See comment in mpagealloc_64bit.go.
|
|
var levelShift = [summaryLevels]uint{
|
|
heapAddrBits - summaryL0Bits,
|
|
heapAddrBits - summaryL0Bits - 1*summaryLevelBits,
|
|
heapAddrBits - summaryL0Bits - 2*summaryLevelBits,
|
|
heapAddrBits - summaryL0Bits - 3*summaryLevelBits,
|
|
}
|
|
|
|
// See comment in mpagealloc_64bit.go.
|
|
var levelLogPages = [summaryLevels]uint{
|
|
logPallocChunkPages + 3*summaryLevelBits,
|
|
logPallocChunkPages + 2*summaryLevelBits,
|
|
logPallocChunkPages + 1*summaryLevelBits,
|
|
logPallocChunkPages,
|
|
}
|
|
|
|
// See mpagealloc_64bit.go for details.
|
|
func (p *pageAlloc) sysInit() {
|
|
// Calculate how much memory all our entries will take up.
|
|
//
|
|
// This should be around 12 KiB or less.
|
|
totalSize := uintptr(0)
|
|
for l := 0; l < summaryLevels; l++ {
|
|
totalSize += (uintptr(1) << (heapAddrBits - levelShift[l])) * pallocSumBytes
|
|
}
|
|
totalSize = alignUp(totalSize, physPageSize)
|
|
|
|
// Reserve memory for all levels in one go. There shouldn't be much for 32-bit.
|
|
reservation := sysReserve(nil, totalSize)
|
|
if reservation == nil {
|
|
throw("failed to reserve page summary memory")
|
|
}
|
|
// There isn't much. Just map it and mark it as used immediately.
|
|
sysMap(reservation, totalSize, p.sysStat)
|
|
sysUsed(reservation, totalSize)
|
|
|
|
// Iterate over the reservation and cut it up into slices.
|
|
//
|
|
// Maintain i as the byte offset from reservation where
|
|
// the new slice should start.
|
|
for l, shift := range levelShift {
|
|
entries := 1 << (heapAddrBits - shift)
|
|
|
|
// Put this reservation into a slice.
|
|
sl := notInHeapSlice{(*notInHeap)(reservation), 0, entries}
|
|
p.summary[l] = *(*[]pallocSum)(unsafe.Pointer(&sl))
|
|
|
|
reservation = add(reservation, uintptr(entries)*pallocSumBytes)
|
|
}
|
|
}
|
|
|
|
// See mpagealloc_64bit.go for details.
|
|
func (p *pageAlloc) sysGrow(base, limit uintptr) {
|
|
if base%pallocChunkBytes != 0 || limit%pallocChunkBytes != 0 {
|
|
print("runtime: base = ", hex(base), ", limit = ", hex(limit), "\n")
|
|
throw("sysGrow bounds not aligned to pallocChunkBytes")
|
|
}
|
|
|
|
// Walk up the tree and update the summary slices.
|
|
for l := len(p.summary) - 1; l >= 0; l-- {
|
|
// Figure out what part of the summary array this new address space needs.
|
|
// Note that we need to align the ranges to the block width (1<<levelBits[l])
|
|
// at this level because the full block is needed to compute the summary for
|
|
// the next level.
|
|
lo, hi := addrsToSummaryRange(l, base, limit)
|
|
_, hi = blockAlignSummaryRange(l, lo, hi)
|
|
if hi > len(p.summary[l]) {
|
|
p.summary[l] = p.summary[l][:hi]
|
|
}
|
|
}
|
|
}
|