Source file src/runtime/malloc_test.go

Documentation: runtime

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

View as plain text