| // Copyright 2011 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. | |
| package runtime_test | |
| import ( | |
| "os" | |
| "runtime" | |
| "runtime/debug" | |
| "testing" | |
| ) | |
| func TestGcSys(t *testing.T) { | |
| if os.Getenv("GOGC") == "off" { | |
| t.Skip("skipping test; GOGC=off in environment") | |
| } | |
| data := struct{ Short bool }{testing.Short()} | |
| got := executeTest(t, testGCSysSource, &data) | |
| want := "OK\n" | |
| if got != want { | |
| t.Fatalf("expected %q, but got %q", want, got) | |
| } | |
| } | |
| const testGCSysSource = ` | |
| package main | |
| import ( | |
| "fmt" | |
| "runtime" | |
| ) | |
| func main() { | |
| runtime.GOMAXPROCS(1) | |
| memstats := new(runtime.MemStats) | |
| runtime.GC() | |
| runtime.ReadMemStats(memstats) | |
| sys := memstats.Sys | |
| runtime.MemProfileRate = 0 // disable profiler | |
| itercount := 1000000 | |
| {{if .Short}} | |
| itercount = 100000 | |
| {{end}} | |
| for i := 0; i < itercount; i++ { | |
| workthegc() | |
| } | |
| // Should only be using a few MB. | |
| // We allocated 100 MB or (if not short) 1 GB. | |
| runtime.ReadMemStats(memstats) | |
| if sys > memstats.Sys { | |
| sys = 0 | |
| } else { | |
| sys = memstats.Sys - sys | |
| } | |
| if sys > 16<<20 { | |
| fmt.Printf("using too much memory: %d bytes\n", sys) | |
| return | |
| } | |
| fmt.Printf("OK\n") | |
| } | |
| func workthegc() []byte { | |
| return make([]byte, 1029) | |
| } | |
| ` | |
| func TestGcDeepNesting(t *testing.T) { | |
| type T [2][2][2][2][2][2][2][2][2][2]*int | |
| a := new(T) | |
| // Prevent the compiler from applying escape analysis. | |
| // This makes sure new(T) is allocated on heap, not on the stack. | |
| t.Logf("%p", a) | |
| a[0][0][0][0][0][0][0][0][0][0] = new(int) | |
| *a[0][0][0][0][0][0][0][0][0][0] = 13 | |
| runtime.GC() | |
| if *a[0][0][0][0][0][0][0][0][0][0] != 13 { | |
| t.Fail() | |
| } | |
| } | |
| func TestGcHashmapIndirection(t *testing.T) { | |
| defer debug.SetGCPercent(debug.SetGCPercent(1)) | |
| runtime.GC() | |
| type T struct { | |
| a [256]int | |
| } | |
| m := make(map[T]T) | |
| for i := 0; i < 2000; i++ { | |
| var a T | |
| a.a[0] = i | |
| m[a] = T{} | |
| } | |
| } | |
| func TestGcArraySlice(t *testing.T) { | |
| type X struct { | |
| buf [1]byte | |
| nextbuf []byte | |
| next *X | |
| } | |
| var head *X | |
| for i := 0; i < 10; i++ { | |
| p := &X{} | |
| p.buf[0] = 42 | |
| p.next = head | |
| if head != nil { | |
| p.nextbuf = head.buf[:] | |
| } | |
| head = p | |
| runtime.GC() | |
| } | |
| for p := head; p != nil; p = p.next { | |
| if p.buf[0] != 42 { | |
| t.Fatal("corrupted heap") | |
| } | |
| } | |
| } | |
| func TestGcRescan(t *testing.T) { | |
| type X struct { | |
| c chan error | |
| nextx *X | |
| } | |
| type Y struct { | |
| X | |
| nexty *Y | |
| p *int | |
| } | |
| var head *Y | |
| for i := 0; i < 10; i++ { | |
| p := &Y{} | |
| p.c = make(chan error) | |
| if head != nil { | |
| p.nextx = &head.X | |
| } | |
| p.nexty = head | |
| p.p = new(int) | |
| *p.p = 42 | |
| head = p | |
| runtime.GC() | |
| } | |
| for p := head; p != nil; p = p.nexty { | |
| if *p.p != 42 { | |
| t.Fatal("corrupted heap") | |
| } | |
| } | |
| } | |
| func BenchmarkSetTypeNoPtr1(b *testing.B) { | |
| type NoPtr1 struct { | |
| p uintptr | |
| } | |
| var p *NoPtr1 | |
| for i := 0; i < b.N; i++ { | |
| p = &NoPtr1{} | |
| } | |
| _ = p | |
| } | |
| func BenchmarkSetTypeNoPtr2(b *testing.B) { | |
| type NoPtr2 struct { | |
| p, q uintptr | |
| } | |
| var p *NoPtr2 | |
| for i := 0; i < b.N; i++ { | |
| p = &NoPtr2{} | |
| } | |
| _ = p | |
| } | |
| func BenchmarkSetTypePtr1(b *testing.B) { | |
| type Ptr1 struct { | |
| p *byte | |
| } | |
| var p *Ptr1 | |
| for i := 0; i < b.N; i++ { | |
| p = &Ptr1{} | |
| } | |
| _ = p | |
| } | |
| func BenchmarkSetTypePtr2(b *testing.B) { | |
| type Ptr2 struct { | |
| p, q *byte | |
| } | |
| var p *Ptr2 | |
| for i := 0; i < b.N; i++ { | |
| p = &Ptr2{} | |
| } | |
| _ = p | |
| } | |
| func BenchmarkAllocation(b *testing.B) { | |
| type T struct { | |
| x, y *byte | |
| } | |
| ngo := runtime.GOMAXPROCS(0) | |
| work := make(chan bool, b.N+ngo) | |
| result := make(chan *T) | |
| for i := 0; i < b.N; i++ { | |
| work <- true | |
| } | |
| for i := 0; i < ngo; i++ { | |
| work <- false | |
| } | |
| for i := 0; i < ngo; i++ { | |
| go func() { | |
| var x *T | |
| for <-work { | |
| for i := 0; i < 1000; i++ { | |
| x = &T{} | |
| } | |
| } | |
| result <- x | |
| }() | |
| } | |
| for i := 0; i < ngo; i++ { | |
| <-result | |
| } | |
| } |