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 <drchase@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

1 files changed, 53 insertions, 50 deletions

diff --git a/src/runtime/mpagecache_test.go b/src/runtime/mpagecache_test.go
index 6cb0620f7b..19b4e04807 100644
--- a/src/runtime/mpagecache_test.go
+++ b/src/runtime/mpagecache_test.go
@@ -269,23 +269,6 @@ func TestPageAllocAllocToCache(t *testing.T) {
 		afterScav   map[ChunkIdx][]BitRange
 	}
 	tests := map[string]test{
-		"AllFree": {
-			beforeAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {},
-			},
-			beforeScav: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{1, 1}, {64, 64}},
-			},
-			hits: []PageCache{
-				NewPageCache(PageBase(BaseChunkIdx, 0), ^uint64(0), 0x2),
-				NewPageCache(PageBase(BaseChunkIdx, 64), ^uint64(0), ^uint64(0)),
-				NewPageCache(PageBase(BaseChunkIdx, 128), ^uint64(0), 0),
-				NewPageCache(PageBase(BaseChunkIdx, 192), ^uint64(0), 0),
-			},
-			afterAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{0, 256}},
-			},
-		},
 		"ManyArena": {
 			beforeAlloc: map[ChunkIdx][]BitRange{
 				BaseChunkIdx:     {{0, PallocChunkPages}},
@@ -306,72 +289,92 @@ func TestPageAllocAllocToCache(t *testing.T) {
 				BaseChunkIdx + 2: {{0, PallocChunkPages}},
 			},
 		},
-		"NotContiguous": {
+
+		"Fail": {
 			beforeAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx:        {{0, PallocChunkPages}},
-				BaseChunkIdx + 0xff: {{0, 0}},
+				BaseChunkIdx: {{0, PallocChunkPages}},
+			},
+			hits: []PageCache{
+				NewPageCache(0, 0, 0),
+				NewPageCache(0, 0, 0),
+				NewPageCache(0, 0, 0),
+			},
+			afterAlloc: map[ChunkIdx][]BitRange{
+				BaseChunkIdx: {{0, PallocChunkPages}},
+			},
+		},
+		"RetainScavBits": {
+			beforeAlloc: map[ChunkIdx][]BitRange{
+				BaseChunkIdx: {{0, 1}, {10, 2}},
 			},
 			beforeScav: map[ChunkIdx][]BitRange{
-				BaseChunkIdx:        {{0, PallocChunkPages}},
-				BaseChunkIdx + 0xff: {{31, 67}},
+				BaseChunkIdx: {{0, 4}, {11, 1}},
 			},
 			hits: []PageCache{
-				NewPageCache(PageBase(BaseChunkIdx+0xff, 0), ^uint64(0), ((uint64(1)<<33)-1)<<31),
+				NewPageCache(PageBase(BaseChunkIdx, 0), ^uint64(0x1|(0x3<<10)), 0x7<<1),
 			},
 			afterAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx:        {{0, PallocChunkPages}},
-				BaseChunkIdx + 0xff: {{0, 64}},
+				BaseChunkIdx: {{0, 64}},
 			},
 			afterScav: map[ChunkIdx][]BitRange{
-				BaseChunkIdx:        {{0, PallocChunkPages}},
-				BaseChunkIdx + 0xff: {{64, 34}},
+				BaseChunkIdx: {{0, 1}, {11, 1}},
 			},
 		},
-		"First": {
+	}
+	if PallocChunkPages >= 512 {
+		tests["AllFree"] = test{
 			beforeAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{0, 32}, {33, 31}, {96, 32}},
+				BaseChunkIdx: {},
 			},
 			beforeScav: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{1, 4}, {31, 5}, {66, 2}},
+				BaseChunkIdx: {{1, 1}, {64, 64}},
 			},
 			hits: []PageCache{
-				NewPageCache(PageBase(BaseChunkIdx, 0), 1<<32, 1<<32),
-				NewPageCache(PageBase(BaseChunkIdx, 64), (uint64(1)<<32)-1, 0x3<<2),
+				NewPageCache(PageBase(BaseChunkIdx, 0), ^uint64(0), 0x2),
+				NewPageCache(PageBase(BaseChunkIdx, 64), ^uint64(0), ^uint64(0)),
+				NewPageCache(PageBase(BaseChunkIdx, 128), ^uint64(0), 0),
+				NewPageCache(PageBase(BaseChunkIdx, 192), ^uint64(0), 0),
 			},
 			afterAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{0, 128}},
+				BaseChunkIdx: {{0, 256}},
 			},
-		},
-		"Fail": {
+		}
+		tests["NotContiguous"] = test{
 			beforeAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{0, PallocChunkPages}},
+				BaseChunkIdx:        {{0, PallocChunkPages}},
+				BaseChunkIdx + 0xff: {{0, 0}},
+			},
+			beforeScav: map[ChunkIdx][]BitRange{
+				BaseChunkIdx:        {{0, PallocChunkPages}},
+				BaseChunkIdx + 0xff: {{31, 67}},
 			},
 			hits: []PageCache{
-				NewPageCache(0, 0, 0),
-				NewPageCache(0, 0, 0),
-				NewPageCache(0, 0, 0),
+				NewPageCache(PageBase(BaseChunkIdx+0xff, 0), ^uint64(0), ((uint64(1)<<33)-1)<<31),
 			},
 			afterAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{0, PallocChunkPages}},
+				BaseChunkIdx:        {{0, PallocChunkPages}},
+				BaseChunkIdx + 0xff: {{0, 64}},
 			},
-		},
-		"RetainScavBits": {
+			afterScav: map[ChunkIdx][]BitRange{
+				BaseChunkIdx:        {{0, PallocChunkPages}},
+				BaseChunkIdx + 0xff: {{64, 34}},
+			},
+		}
+		tests["First"] = test{
 			beforeAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{0, 1}, {10, 2}},
+				BaseChunkIdx: {{0, 32}, {33, 31}, {96, 32}},
 			},
 			beforeScav: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{0, 4}, {11, 1}},
+				BaseChunkIdx: {{1, 4}, {31, 5}, {66, 2}},
 			},
 			hits: []PageCache{
-				NewPageCache(PageBase(BaseChunkIdx, 0), ^uint64(0x1|(0x3<<10)), 0x7<<1),
+				NewPageCache(PageBase(BaseChunkIdx, 0), 1<<32, 1<<32),
+				NewPageCache(PageBase(BaseChunkIdx, 64), (uint64(1)<<32)-1, 0x3<<2),
 			},
 			afterAlloc: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{0, 64}},
-			},
-			afterScav: map[ChunkIdx][]BitRange{
-				BaseChunkIdx: {{0, 1}, {11, 1}},
+				BaseChunkIdx: {{0, 128}},
 			},
-		},
+		}
 	}
 	// Disable these tests on iOS since we have a small address space.
 	// See #46860.