Source file src/runtime/malloc_test.go

     1  // Copyright 2013 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package runtime_test
     6  
     7  import (
     8  	"flag"
     9  	"fmt"
    10  	"internal/asan"
    11  	"internal/race"
    12  	"internal/testenv"
    13  	"os"
    14  	"os/exec"
    15  	"reflect"
    16  	"runtime"
    17  	. "runtime"
    18  	"strings"
    19  	"sync/atomic"
    20  	"testing"
    21  	"time"
    22  	"unsafe"
    23  )
    24  
    25  var testMemStatsCount int
    26  
    27  func TestMemStats(t *testing.T) {
    28  	testMemStatsCount++
    29  
    30  	// Make sure there's at least one forced GC.
    31  	GC()
    32  
    33  	// Test that MemStats has sane values.
    34  	st := new(MemStats)
    35  	ReadMemStats(st)
    36  
    37  	nz := func(x any) error {
    38  		if x != reflect.Zero(reflect.TypeOf(x)).Interface() {
    39  			return nil
    40  		}
    41  		return fmt.Errorf("zero value")
    42  	}
    43  	le := func(thresh float64) func(any) error {
    44  		return func(x any) error {
    45  			// These sanity tests aren't necessarily valid
    46  			// with high -test.count values, so only run
    47  			// them once.
    48  			if testMemStatsCount > 1 {
    49  				return nil
    50  			}
    51  
    52  			if reflect.ValueOf(x).Convert(reflect.TypeOf(thresh)).Float() < thresh {
    53  				return nil
    54  			}
    55  			return fmt.Errorf("insanely high value (overflow?); want <= %v", thresh)
    56  		}
    57  	}
    58  	eq := func(x any) func(any) error {
    59  		return func(y any) error {
    60  			if x == y {
    61  				return nil
    62  			}
    63  			return fmt.Errorf("want %v", x)
    64  		}
    65  	}
    66  	// Of the uint fields, HeapReleased, HeapIdle can be 0.
    67  	// PauseTotalNs can be 0 if timer resolution is poor.
    68  	fields := map[string][]func(any) error{
    69  		"Alloc": {nz, le(1e10)}, "TotalAlloc": {nz, le(1e11)}, "Sys": {nz, le(1e10)},
    70  		"Lookups": {eq(uint64(0))}, "Mallocs": {nz, le(1e10)}, "Frees": {nz, le(1e10)},
    71  		"HeapAlloc": {nz, le(1e10)}, "HeapSys": {nz, le(1e10)}, "HeapIdle": {le(1e10)},
    72  		"HeapInuse": {nz, le(1e10)}, "HeapReleased": {le(1e10)}, "HeapObjects": {nz, le(1e10)},
    73  		"StackInuse": {nz, le(1e10)}, "StackSys": {nz, le(1e10)},
    74  		"MSpanInuse": {nz, le(1e10)}, "MSpanSys": {nz, le(1e10)},
    75  		"MCacheInuse": {nz, le(1e10)}, "MCacheSys": {nz, le(1e10)},
    76  		"BuckHashSys": {nz, le(1e10)}, "GCSys": {nz, le(1e10)}, "OtherSys": {nz, le(1e10)},
    77  		"NextGC": {nz, le(1e10)}, "LastGC": {nz},
    78  		"PauseTotalNs": {le(1e11)}, "PauseNs": nil, "PauseEnd": nil,
    79  		"NumGC": {nz, le(1e9)}, "NumForcedGC": {nz, le(1e9)},
    80  		"GCCPUFraction": {le(0.99)}, "EnableGC": {eq(true)}, "DebugGC": {eq(false)},
    81  		"BySize": nil,
    82  	}
    83  
    84  	rst := reflect.ValueOf(st).Elem()
    85  	for i := 0; i < rst.Type().NumField(); i++ {
    86  		name, val := rst.Type().Field(i).Name, rst.Field(i).Interface()
    87  		checks, ok := fields[name]
    88  		if !ok {
    89  			t.Errorf("unknown MemStats field %s", name)
    90  			continue
    91  		}
    92  		for _, check := range checks {
    93  			if err := check(val); err != nil {
    94  				t.Errorf("%s = %v: %s", name, val, err)
    95  			}
    96  		}
    97  	}
    98  
    99  	if st.Sys != st.HeapSys+st.StackSys+st.MSpanSys+st.MCacheSys+
   100  		st.BuckHashSys+st.GCSys+st.OtherSys {
   101  		t.Fatalf("Bad sys value: %+v", *st)
   102  	}
   103  
   104  	if st.HeapIdle+st.HeapInuse != st.HeapSys {
   105  		t.Fatalf("HeapIdle(%d) + HeapInuse(%d) should be equal to HeapSys(%d), but isn't.", st.HeapIdle, st.HeapInuse, st.HeapSys)
   106  	}
   107  
   108  	if lpe := st.PauseEnd[int(st.NumGC+255)%len(st.PauseEnd)]; st.LastGC != lpe {
   109  		t.Fatalf("LastGC(%d) != last PauseEnd(%d)", st.LastGC, lpe)
   110  	}
   111  
   112  	var pauseTotal uint64
   113  	for _, pause := range st.PauseNs {
   114  		pauseTotal += pause
   115  	}
   116  	if int(st.NumGC) < len(st.PauseNs) {
   117  		// We have all pauses, so this should be exact.
   118  		if st.PauseTotalNs != pauseTotal {
   119  			t.Fatalf("PauseTotalNs(%d) != sum PauseNs(%d)", st.PauseTotalNs, pauseTotal)
   120  		}
   121  		for i := int(st.NumGC); i < len(st.PauseNs); i++ {
   122  			if st.PauseNs[i] != 0 {
   123  				t.Fatalf("Non-zero PauseNs[%d]: %+v", i, st)
   124  			}
   125  			if st.PauseEnd[i] != 0 {
   126  				t.Fatalf("Non-zero PauseEnd[%d]: %+v", i, st)
   127  			}
   128  		}
   129  	} else {
   130  		if st.PauseTotalNs < pauseTotal {
   131  			t.Fatalf("PauseTotalNs(%d) < sum PauseNs(%d)", st.PauseTotalNs, pauseTotal)
   132  		}
   133  	}
   134  
   135  	if st.NumForcedGC > st.NumGC {
   136  		t.Fatalf("NumForcedGC(%d) > NumGC(%d)", st.NumForcedGC, st.NumGC)
   137  	}
   138  }
   139  
   140  func TestStringConcatenationAllocs(t *testing.T) {
   141  	n := testing.AllocsPerRun(1e3, func() {
   142  		b := make([]byte, 10)
   143  		for i := 0; i < 10; i++ {
   144  			b[i] = byte(i) + '0'
   145  		}
   146  		s := "foo" + string(b)
   147  		if want := "foo0123456789"; s != want {
   148  			t.Fatalf("want %v, got %v", want, s)
   149  		}
   150  	})
   151  	// Only string concatenation allocates.
   152  	if n != 1 {
   153  		t.Fatalf("want 1 allocation, got %v", n)
   154  	}
   155  }
   156  
   157  func TestTinyAlloc(t *testing.T) {
   158  	if runtime.Raceenabled {
   159  		t.Skip("tinyalloc suppressed when running in race mode")
   160  	}
   161  	if asan.Enabled {
   162  		t.Skip("tinyalloc suppressed when running in asan mode due to redzone")
   163  	}
   164  	const N = 16
   165  	var v [N]unsafe.Pointer
   166  	for i := range v {
   167  		v[i] = unsafe.Pointer(new(byte))
   168  	}
   169  
   170  	chunks := make(map[uintptr]bool, N)
   171  	for _, p := range v {
   172  		chunks[uintptr(p)&^7] = true
   173  	}
   174  
   175  	if len(chunks) == N {
   176  		t.Fatal("no bytes allocated within the same 8-byte chunk")
   177  	}
   178  }
   179  
   180  type obj12 struct {
   181  	a uint64
   182  	b uint32
   183  }
   184  
   185  func TestTinyAllocIssue37262(t *testing.T) {
   186  	if runtime.Raceenabled {
   187  		t.Skip("tinyalloc suppressed when running in race mode")
   188  	}
   189  	if asan.Enabled {
   190  		t.Skip("tinyalloc suppressed when running in asan mode due to redzone")
   191  	}
   192  	// Try to cause an alignment access fault
   193  	// by atomically accessing the first 64-bit
   194  	// value of a tiny-allocated object.
   195  	// See issue 37262 for details.
   196  
   197  	// GC twice, once to reach a stable heap state
   198  	// and again to make sure we finish the sweep phase.
   199  	runtime.GC()
   200  	runtime.GC()
   201  
   202  	// Disable preemption so we stay on one P's tiny allocator and
   203  	// nothing else allocates from it.
   204  	runtime.Acquirem()
   205  
   206  	// Make 1-byte allocations until we get a fresh tiny slot.
   207  	aligned := false
   208  	for i := 0; i < 16; i++ {
   209  		x := runtime.Escape(new(byte))
   210  		if uintptr(unsafe.Pointer(x))&0xf == 0xf {
   211  			aligned = true
   212  			break
   213  		}
   214  	}
   215  	if !aligned {
   216  		runtime.Releasem()
   217  		t.Fatal("unable to get a fresh tiny slot")
   218  	}
   219  
   220  	// Create a 4-byte object so that the current
   221  	// tiny slot is partially filled.
   222  	runtime.Escape(new(uint32))
   223  
   224  	// Create a 12-byte object, which fits into the
   225  	// tiny slot. If it actually gets place there,
   226  	// then the field "a" will be improperly aligned
   227  	// for atomic access on 32-bit architectures.
   228  	// This won't be true if issue 36606 gets resolved.
   229  	tinyObj12 := runtime.Escape(new(obj12))
   230  
   231  	// Try to atomically access "x.a".
   232  	atomic.StoreUint64(&tinyObj12.a, 10)
   233  
   234  	runtime.Releasem()
   235  }
   236  
   237  func TestPageCacheLeak(t *testing.T) {
   238  	defer GOMAXPROCS(GOMAXPROCS(1))
   239  	leaked := PageCachePagesLeaked()
   240  	if leaked != 0 {
   241  		t.Fatalf("found %d leaked pages in page caches", leaked)
   242  	}
   243  }
   244  
   245  func TestPhysicalMemoryUtilization(t *testing.T) {
   246  	got := runTestProg(t, "testprog", "GCPhys")
   247  	want := "OK\n"
   248  	if got != want {
   249  		t.Fatalf("expected %q, but got %q", want, got)
   250  	}
   251  }
   252  
   253  func TestScavengedBitsCleared(t *testing.T) {
   254  	var mismatches [128]BitsMismatch
   255  	if n, ok := CheckScavengedBitsCleared(mismatches[:]); !ok {
   256  		t.Errorf("uncleared scavenged bits")
   257  		for _, m := range mismatches[:n] {
   258  			t.Logf("\t@ address 0x%x", m.Base)
   259  			t.Logf("\t|  got: %064b", m.Got)
   260  			t.Logf("\t| want: %064b", m.Want)
   261  		}
   262  		t.FailNow()
   263  	}
   264  }
   265  
   266  type acLink struct {
   267  	x [1 << 20]byte
   268  }
   269  
   270  var arenaCollisionSink []*acLink
   271  
   272  func TestArenaCollision(t *testing.T) {
   273  	// Test that mheap.sysAlloc handles collisions with other
   274  	// memory mappings.
   275  	if os.Getenv("TEST_ARENA_COLLISION") != "1" {
   276  		cmd := testenv.CleanCmdEnv(exec.Command(testenv.Executable(t), "-test.run=^TestArenaCollision$", "-test.v"))
   277  		cmd.Env = append(cmd.Env, "TEST_ARENA_COLLISION=1")
   278  		out, err := cmd.CombinedOutput()
   279  		if race.Enabled {
   280  			// This test runs the runtime out of hint
   281  			// addresses, so it will start mapping the
   282  			// heap wherever it can. The race detector
   283  			// doesn't support this, so look for the
   284  			// expected failure.
   285  			if want := "too many address space collisions"; !strings.Contains(string(out), want) {
   286  				t.Fatalf("want %q, got:\n%s", want, string(out))
   287  			}
   288  		} else if !strings.Contains(string(out), "PASS\n") || err != nil {
   289  			t.Fatalf("%s\n(exit status %v)", string(out), err)
   290  		}
   291  		return
   292  	}
   293  	disallowed := [][2]uintptr{}
   294  	// Drop all but the next 3 hints. 64-bit has a lot of hints,
   295  	// so it would take a lot of memory to go through all of them.
   296  	KeepNArenaHints(3)
   297  	// Consume these 3 hints and force the runtime to find some
   298  	// fallback hints.
   299  	for i := 0; i < 5; i++ {
   300  		// Reserve memory at the next hint so it can't be used
   301  		// for the heap.
   302  		start, end, ok := MapNextArenaHint()
   303  		if !ok {
   304  			t.Skipf("failed to reserve memory at next arena hint [%#x, %#x)", start, end)
   305  		}
   306  		t.Logf("reserved [%#x, %#x)", start, end)
   307  		disallowed = append(disallowed, [2]uintptr{start, end})
   308  		// Allocate until the runtime tries to use the hint we
   309  		// just mapped over.
   310  		hint := GetNextArenaHint()
   311  		for GetNextArenaHint() == hint {
   312  			ac := new(acLink)
   313  			arenaCollisionSink = append(arenaCollisionSink, ac)
   314  			// The allocation must not have fallen into
   315  			// one of the reserved regions.
   316  			p := uintptr(unsafe.Pointer(ac))
   317  			for _, d := range disallowed {
   318  				if d[0] <= p && p < d[1] {
   319  					t.Fatalf("allocation %#x in reserved region [%#x, %#x)", p, d[0], d[1])
   320  				}
   321  			}
   322  		}
   323  	}
   324  }
   325  
   326  func BenchmarkMalloc8(b *testing.B) {
   327  	for i := 0; i < b.N; i++ {
   328  		p := new(int64)
   329  		Escape(p)
   330  	}
   331  }
   332  
   333  func BenchmarkMalloc16(b *testing.B) {
   334  	for i := 0; i < b.N; i++ {
   335  		p := new([2]int64)
   336  		Escape(p)
   337  	}
   338  }
   339  
   340  func BenchmarkMallocTypeInfo8(b *testing.B) {
   341  	for i := 0; i < b.N; i++ {
   342  		p := new(struct {
   343  			p [8 / unsafe.Sizeof(uintptr(0))]*int
   344  		})
   345  		Escape(p)
   346  	}
   347  }
   348  
   349  func BenchmarkMallocTypeInfo16(b *testing.B) {
   350  	for i := 0; i < b.N; i++ {
   351  		p := new(struct {
   352  			p [16 / unsafe.Sizeof(uintptr(0))]*int
   353  		})
   354  		Escape(p)
   355  	}
   356  }
   357  
   358  type LargeStruct struct {
   359  	x [16][]byte
   360  }
   361  
   362  func BenchmarkMallocLargeStruct(b *testing.B) {
   363  	for i := 0; i < b.N; i++ {
   364  		p := make([]LargeStruct, 2)
   365  		Escape(p)
   366  	}
   367  }
   368  
   369  var n = flag.Int("n", 1000, "number of goroutines")
   370  
   371  func BenchmarkGoroutineSelect(b *testing.B) {
   372  	quit := make(chan struct{})
   373  	read := func(ch chan struct{}) {
   374  		for {
   375  			select {
   376  			case _, ok := <-ch:
   377  				if !ok {
   378  					return
   379  				}
   380  			case <-quit:
   381  				return
   382  			}
   383  		}
   384  	}
   385  	benchHelper(b, *n, read)
   386  }
   387  
   388  func BenchmarkGoroutineBlocking(b *testing.B) {
   389  	read := func(ch chan struct{}) {
   390  		for {
   391  			if _, ok := <-ch; !ok {
   392  				return
   393  			}
   394  		}
   395  	}
   396  	benchHelper(b, *n, read)
   397  }
   398  
   399  func BenchmarkGoroutineForRange(b *testing.B) {
   400  	read := func(ch chan struct{}) {
   401  		for range ch {
   402  		}
   403  	}
   404  	benchHelper(b, *n, read)
   405  }
   406  
   407  func benchHelper(b *testing.B, n int, read func(chan struct{})) {
   408  	m := make([]chan struct{}, n)
   409  	for i := range m {
   410  		m[i] = make(chan struct{}, 1)
   411  		go read(m[i])
   412  	}
   413  	b.StopTimer()
   414  	b.ResetTimer()
   415  	GC()
   416  
   417  	for i := 0; i < b.N; i++ {
   418  		for _, ch := range m {
   419  			if ch != nil {
   420  				ch <- struct{}{}
   421  			}
   422  		}
   423  		time.Sleep(10 * time.Millisecond)
   424  		b.StartTimer()
   425  		GC()
   426  		b.StopTimer()
   427  	}
   428  
   429  	for _, ch := range m {
   430  		close(ch)
   431  	}
   432  	time.Sleep(10 * time.Millisecond)
   433  }
   434  
   435  func BenchmarkGoroutineIdle(b *testing.B) {
   436  	quit := make(chan struct{})
   437  	fn := func() {
   438  		<-quit
   439  	}
   440  	for i := 0; i < *n; i++ {
   441  		go fn()
   442  	}
   443  
   444  	GC()
   445  	b.ResetTimer()
   446  
   447  	for i := 0; i < b.N; i++ {
   448  		GC()
   449  	}
   450  
   451  	b.StopTimer()
   452  	close(quit)
   453  	time.Sleep(10 * time.Millisecond)
   454  }
   455  

View as plain text