runtime: use a smaller arena size on Wasm

On Wasm, some programs have very small heap. Currently,
we use 4 MB arena size (like all other 32-bit platforms).
For a very small program, it needs to allocate one heap
arena, 4 MB size at a 4 MB aligned address. So we'll
need 8 MB of linear memory, whereas only a smaller
portion is actually used by the program. On Wasm, samll
programs are not uncommon (e.g. WASI plugins), and
users are concerned about the memory usage.

This CL switches to a smaller arena size, as well as a
smaller page allocator chunk size (both are now 512 KB).
So the heap will be grown in 512 KB granularity. For a
helloworld program, it now uses less than 3 MB of
linear memory, instead of 8 MB.

Change-Id: Ibd66c1fa6e794a12c00906cbacc8f2e410f196c4
Reviewed-on: https://go-review.googlesource.com/c/go/+/683296
Reviewed-by: David Chase <[email protected]>
Reviewed-by: Michael Knyszek <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: cherrymui

src/runtime/malloc.go

@@ -233,27 +233,30 @@ const (
 	//      ios/arm64         40         4MB           1  256K  (2MB)
 	//       */32-bit         32         4MB           1  1024  (4KB)
 	//     */mips(le)         31         4MB           1   512  (2KB)
+	//           wasm         32       512KB           1  8192 (64KB)
 
 	// heapArenaBytes is the size of a heap arena. The heap
 	// consists of mappings of size heapArenaBytes, aligned to
 	// heapArenaBytes. The initial heap mapping is one arena.
 	//
-	// This is currently 64MB on 64-bit non-Windows and 4MB on
-	// 32-bit and on Windows. We use smaller arenas on Windows
-	// because all committed memory is charged to the process,
-	// even if it's not touched. Hence, for processes with small
-	// heaps, the mapped arena space needs to be commensurate.
-	// This is particularly important with the race detector,
-	// since it significantly amplifies the cost of committed
-	// memory.
+	// This is currently 64MB on 64-bit non-Windows, 4MB on
+	// 32-bit and on Windows, and 512KB on Wasm. We use smaller
+	// arenas on Windows because all committed memory is charged
+	// to the process, even if it's not touched. Hence, for
+	// processes with small heaps, the mapped arena space needs
+	// to be commensurate. This is particularly important with
+	// the race detector, since it significantly amplifies the
+	// cost of committed memory. We use smaller arenas on Wasm
+	// because some Wasm programs have very small heap, and
+	// everything in the Wasm linear memory is charged.
 	heapArenaBytes = 1 << logHeapArenaBytes
 
 	heapArenaWords = heapArenaBytes / goarch.PtrSize
 
 	// logHeapArenaBytes is log_2 of heapArenaBytes. For clarity,
 	// prefer using heapArenaBytes where possible (we need the
 	// constant to compute some other constants).
-	logHeapArenaBytes = (6+20)*(_64bit*(1-goos.IsWindows)*(1-goarch.IsWasm)*(1-goos.IsIos*goarch.IsArm64)) + (2+20)*(_64bit*goos.IsWindows) + (2+20)*(1-_64bit) + (2+20)*goarch.IsWasm + (2+20)*goos.IsIos*goarch.IsArm64
+	logHeapArenaBytes = (6+20)*(_64bit*(1-goos.IsWindows)*(1-goarch.IsWasm)*(1-goos.IsIos*goarch.IsArm64)) + (2+20)*(_64bit*goos.IsWindows) + (2+20)*(1-_64bit) + (9+10)*goarch.IsWasm + (2+20)*goos.IsIos*goarch.IsArm64
 
 	// heapArenaBitmapWords is the size of each heap arena's bitmap in uintptrs.
 	heapArenaBitmapWords = heapArenaWords / (8 * goarch.PtrSize)

src/runtime/mgcmark.go

@@ -50,7 +50,7 @@ const (
 	//
 	// Must be a multiple of the pageInUse bitmap element size and
 	// must also evenly divide pagesPerArena.
-	pagesPerSpanRoot = 512
+	pagesPerSpanRoot = min(512, pagesPerArena)
 )
 
 // gcPrepareMarkRoots queues root scanning jobs (stacks, globals, and

src/runtime/mgcscavenge_test.go

@@ -121,13 +121,17 @@ func TestPallocDataFindScavengeCandidate(t *testing.T) {
 			max:       PallocChunkPages,
 			want:      BitRange{41, 1},
 		},
-		"MultiMin1": {
-			alloc:     []BitRange{{0, 63}, {65, 20}, {87, PallocChunkPages - 87}},
+	}
+	if PallocChunkPages >= 512 {
+		// avoid constant overflow when PallocChunkPages is small
+		var pallocChunkPages uint = PallocChunkPages
+		tests["MultiMin1"] = test{
+			alloc:     []BitRange{{0, 63}, {65, 20}, {87, pallocChunkPages - 87}},
 			scavenged: []BitRange{{86, 1}},
 			min:       1,
 			max:       PallocChunkPages,
 			want:      BitRange{85, 1},
-		},
+		}
 	}
 	// Try out different page minimums.
 	for m := uintptr(1); m <= 64; m *= 2 {
@@ -162,25 +166,27 @@ func TestPallocDataFindScavengeCandidate(t *testing.T) {
 			max:   PallocChunkPages,
 			want:  BitRange{PallocChunkPages - uint(m), uint(m)},
 		}
-		tests["Straddle64"+suffix] = test{
-			alloc: []BitRange{{0, 64 - uint(m)}, {64 + uint(m), PallocChunkPages - (64 + uint(m))}},
-			min:   m,
-			max:   2 * m,
-			want:  BitRange{64 - uint(m), 2 * uint(m)},
-		}
-		tests["BottomEdge64WithFull"+suffix] = test{
-			alloc:     []BitRange{{64, 64}, {128 + 3*uint(m), PallocChunkPages - (128 + 3*uint(m))}},
-			scavenged: []BitRange{{1, 10}},
-			min:       m,
-			max:       3 * m,
-			want:      BitRange{128, 3 * uint(m)},
-		}
-		tests["BottomEdge64WithPocket"+suffix] = test{
-			alloc:     []BitRange{{64, 62}, {127, 1}, {128 + 3*uint(m), PallocChunkPages - (128 + 3*uint(m))}},
-			scavenged: []BitRange{{1, 10}},
-			min:       m,
-			max:       3 * m,
-			want:      BitRange{128, 3 * uint(m)},
+		if PallocChunkPages >= 512 {
+			tests["Straddle64"+suffix] = test{
+				alloc: []BitRange{{0, 64 - uint(m)}, {64 + uint(m), PallocChunkPages - (64 + uint(m))}},
+				min:   m,
+				max:   2 * m,
+				want:  BitRange{64 - uint(m), 2 * uint(m)},
+			}
+			tests["BottomEdge64WithFull"+suffix] = test{
+				alloc:     []BitRange{{64, 64}, {128 + 3*uint(m), PallocChunkPages - (128 + 3*uint(m))}},
+				scavenged: []BitRange{{1, 10}},
+				min:       m,
+				max:       3 * m,
+				want:      BitRange{128, 3 * uint(m)},
+			}
+			tests["BottomEdge64WithPocket"+suffix] = test{
+				alloc:     []BitRange{{64, 62}, {127, 1}, {128 + 3*uint(m), PallocChunkPages - (128 + 3*uint(m))}},
+				scavenged: []BitRange{{1, 10}},
+				min:       m,
+				max:       3 * m,
+				want:      BitRange{128, 3 * uint(m)},
+			}
 		}
 		tests["Max0"+suffix] = test{
 			scavenged: []BitRange{{0, PallocChunkPages - uint(m)}},
@@ -204,23 +210,29 @@ func TestPallocDataFindScavengeCandidate(t *testing.T) {
 			}
 		}
 		if m > 1 {
-			tests["MaxUnaligned"+suffix] = test{
-				scavenged: []BitRange{{0, PallocChunkPages - uint(m*2-1)}},
-				min:       m,
-				max:       m - 2,
-				want:      BitRange{PallocChunkPages - uint(m), uint(m)},
-			}
-			tests["SkipSmall"+suffix] = test{
-				alloc: []BitRange{{0, 64 - uint(m)}, {64, 5}, {70, 11}, {82, PallocChunkPages - 82}},
-				min:   m,
-				max:   m,
-				want:  BitRange{64 - uint(m), uint(m)},
+			if PallocChunkPages >= m*2 {
+				tests["MaxUnaligned"+suffix] = test{
+					scavenged: []BitRange{{0, PallocChunkPages - uint(m*2-1)}},
+					min:       m,
+					max:       m - 2,
+					want:      BitRange{PallocChunkPages - uint(m), uint(m)},
+				}
 			}
-			tests["SkipMisaligned"+suffix] = test{
-				alloc: []BitRange{{0, 64 - uint(m)}, {64, 63}, {127 + uint(m), PallocChunkPages - (127 + uint(m))}},
-				min:   m,
-				max:   m,
-				want:  BitRange{64 - uint(m), uint(m)},
+			if PallocChunkPages >= 512 {
+				// avoid constant overflow when PallocChunkPages is small
+				var PallocChunkPages uint = PallocChunkPages
+				tests["SkipSmall"+suffix] = test{
+					alloc: []BitRange{{0, 64 - uint(m)}, {64, 5}, {70, 11}, {82, PallocChunkPages - 82}},
+					min:   m,
+					max:   m,
+					want:  BitRange{64 - uint(m), uint(m)},
+				}
+				tests["SkipMisaligned"+suffix] = test{
+					alloc: []BitRange{{0, 64 - uint(m)}, {64, 63}, {127 + uint(m), PallocChunkPages - (127 + uint(m))}},
+					min:   m,
+					max:   m,
+					want:  BitRange{64 - uint(m), uint(m)},
+				}
 			}
 			tests["MaxLessThan"+suffix] = test{
 				scavenged: []BitRange{{0, PallocChunkPages - uint(m)}},
@@ -641,7 +653,7 @@ func TestScavengeIndex(t *testing.T) {
 		mark func(markFunc)
 		find func(findFunc)
 	}
-	for _, test := range []testCase{
+	tests := []testCase{
 		{
 			name: "Uninitialized",
 			mark: func(_ markFunc) {},
@@ -692,26 +704,6 @@ func TestScavengeIndex(t *testing.T) {
 				find(BaseChunkIdx, PallocChunkPages-1)
 			},
 		},
-		{
-			name: "TwoChunks",
-			mark: func(mark markFunc) {
-				mark(PageBase(BaseChunkIdx, 128), PageBase(BaseChunkIdx+1, 128))
-			},
-			find: func(find findFunc) {
-				find(BaseChunkIdx+1, 127)
-				find(BaseChunkIdx, PallocChunkPages-1)
-			},
-		},
-		{
-			name: "TwoChunksOffset",
-			mark: func(mark markFunc) {
-				mark(PageBase(BaseChunkIdx+7, 128), PageBase(BaseChunkIdx+8, 129))
-			},
-			find: func(find findFunc) {
-				find(BaseChunkIdx+8, 128)
-				find(BaseChunkIdx+7, PallocChunkPages-1)
-			},
-		},
 		{
 			name: "SevenChunksOffset",
 			mark: func(mark markFunc) {
@@ -793,7 +785,32 @@ func TestScavengeIndex(t *testing.T) {
 				}
 			},
 		},
-	} {
+	}
+	if PallocChunkPages >= 512 {
+		tests = append(tests,
+			testCase{
+				name: "TwoChunks",
+				mark: func(mark markFunc) {
+					mark(PageBase(BaseChunkIdx, 128), PageBase(BaseChunkIdx+1, 128))
+				},
+				find: func(find findFunc) {
+					find(BaseChunkIdx+1, 127)
+					find(BaseChunkIdx, PallocChunkPages-1)
+				},
+			},
+			testCase{
+				name: "TwoChunksOffset",
+				mark: func(mark markFunc) {
+					mark(PageBase(BaseChunkIdx+7, 128), PageBase(BaseChunkIdx+8, 129))
+				},
+				find: func(find findFunc) {
+					find(BaseChunkIdx+8, 128)
+					find(BaseChunkIdx+7, PallocChunkPages-1)
+				},
+			},
+		)
+	}
+	for _, test := range tests {
 		test := test
 		t.Run("Bg/"+test.name, func(t *testing.T) {
 			mark, find, nextGen := setup(t, false)
@@ -830,8 +847,10 @@ func TestScavengeIndex(t *testing.T) {
 }
 
 func TestScavChunkDataPack(t *testing.T) {
-	if !CheckPackScavChunkData(1918237402, 512, 512, 0b11) {
-		t.Error("failed pack/unpack check for scavChunkData 1")
+	if PallocChunkPages >= 512 {
+		if !CheckPackScavChunkData(1918237402, 512, 512, 0b11) {
+			t.Error("failed pack/unpack check for scavChunkData 1")
+		}
 	}
 	if !CheckPackScavChunkData(^uint32(0), 12, 0, 0b00) {
 		t.Error("failed pack/unpack check for scavChunkData 2")

src/runtime/mheap.go

@@ -47,7 +47,7 @@ const (
 	//
 	// Must be a multiple of the pageInUse bitmap element size and
 	// must also evenly divide pagesPerArena.
-	pagesPerReclaimerChunk = 512
+	pagesPerReclaimerChunk = min(512, pagesPerArena)
 
 	// physPageAlignedStacks indicates whether stack allocations must be
 	// physical page aligned. This is a requirement for MAP_STACK on

src/runtime/mpagealloc.go

@@ -48,17 +48,20 @@
 package runtime
 
 import (
+	"internal/goarch"
 	"internal/runtime/atomic"
 	"internal/runtime/gc"
 	"unsafe"
 )
 
 const (
 	// The size of a bitmap chunk, i.e. the amount of bits (that is, pages) to consider
-	// in the bitmap at once.
+	// in the bitmap at once. It is 4MB on most platforms, except on Wasm it is 512KB.
+	// We use a smaller chuck size on Wasm for the same reason as the smaller arena
+	// size (see heapArenaBytes).
 	pallocChunkPages    = 1 << logPallocChunkPages
 	pallocChunkBytes    = pallocChunkPages * pageSize
-	logPallocChunkPages = 9
+	logPallocChunkPages = 9*(1-goarch.IsWasm) + 6*goarch.IsWasm
 	logPallocChunkBytes = logPallocChunkPages + gc.PageShift
 
 	// The number of radix bits for each level.
@@ -220,6 +223,7 @@ type pageAlloc struct {
 	// heapAddrBits | L1 Bits | L2 Bits | L2 Entry Size
 	// ------------------------------------------------
 	// 32           | 0       | 10      | 128 KiB
+	// 32 (wasm)    | 0       | 13      | 128 KiB
 	// 33 (iOS)     | 0       | 11      | 256 KiB
 	// 48           | 13      | 13      | 1 MiB
 	//