Source file src/runtime/stack_test.go

Documentation: runtime

     1  // Copyright 2012 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  	"bytes"
     9  	"fmt"
    10  	"os"
    11  	"reflect"
    12  	"regexp"
    13  	. "runtime"
    14  	"strconv"
    15  	"strings"
    16  	"sync"
    17  	"sync/atomic"
    18  	"testing"
    19  	"time"
    20  	_ "unsafe" // for go:linkname
    21  )
    22  
    23  // TestStackMem measures per-thread stack segment cache behavior.
    24  // The test consumed up to 500MB in the past.
    25  func TestStackMem(t *testing.T) {
    26  	const (
    27  		BatchSize      = 32
    28  		BatchCount     = 256
    29  		ArraySize      = 1024
    30  		RecursionDepth = 128
    31  	)
    32  	if testing.Short() {
    33  		return
    34  	}
    35  	defer GOMAXPROCS(GOMAXPROCS(BatchSize))
    36  	s0 := new(MemStats)
    37  	ReadMemStats(s0)
    38  	for b := 0; b < BatchCount; b++ {
    39  		c := make(chan bool, BatchSize)
    40  		for i := 0; i < BatchSize; i++ {
    41  			go func() {
    42  				var f func(k int, a [ArraySize]byte)
    43  				f = func(k int, a [ArraySize]byte) {
    44  					if k == 0 {
    45  						time.Sleep(time.Millisecond)
    46  						return
    47  					}
    48  					f(k-1, a)
    49  				}
    50  				f(RecursionDepth, [ArraySize]byte{})
    51  				c <- true
    52  			}()
    53  		}
    54  		for i := 0; i < BatchSize; i++ {
    55  			<-c
    56  		}
    57  
    58  		// The goroutines have signaled via c that they are ready to exit.
    59  		// Give them a chance to exit by sleeping. If we don't wait, we
    60  		// might not reuse them on the next batch.
    61  		time.Sleep(10 * time.Millisecond)
    62  	}
    63  	s1 := new(MemStats)
    64  	ReadMemStats(s1)
    65  	consumed := int64(s1.StackSys - s0.StackSys)
    66  	t.Logf("Consumed %vMB for stack mem", consumed>>20)
    67  	estimate := int64(8 * BatchSize * ArraySize * RecursionDepth) // 8 is to reduce flakiness.
    68  	if consumed > estimate {
    69  		t.Fatalf("Stack mem: want %v, got %v", estimate, consumed)
    70  	}
    71  	// Due to broken stack memory accounting (https://golang.org/issue/7468),
    72  	// StackInuse can decrease during function execution, so we cast the values to int64.
    73  	inuse := int64(s1.StackInuse) - int64(s0.StackInuse)
    74  	t.Logf("Inuse %vMB for stack mem", inuse>>20)
    75  	if inuse > 4<<20 {
    76  		t.Fatalf("Stack inuse: want %v, got %v", 4<<20, inuse)
    77  	}
    78  }
    79  
    80  // Test stack growing in different contexts.
    81  func TestStackGrowth(t *testing.T) {
    82  	if *flagQuick {
    83  		t.Skip("-quick")
    84  	}
    85  
    86  	if GOARCH == "wasm" {
    87  		t.Skip("fails on wasm (too slow?)")
    88  	}
    89  
    90  	// Don't make this test parallel as this makes the 20 second
    91  	// timeout unreliable on slow builders. (See issue #19381.)
    92  
    93  	var wg sync.WaitGroup
    94  
    95  	// in a normal goroutine
    96  	var growDuration time.Duration // For debugging failures
    97  	wg.Add(1)
    98  	go func() {
    99  		defer wg.Done()
   100  		start := time.Now()
   101  		growStack(nil)
   102  		growDuration = time.Since(start)
   103  	}()
   104  	wg.Wait()
   105  
   106  	// in locked goroutine
   107  	wg.Add(1)
   108  	go func() {
   109  		defer wg.Done()
   110  		LockOSThread()
   111  		growStack(nil)
   112  		UnlockOSThread()
   113  	}()
   114  	wg.Wait()
   115  
   116  	// in finalizer
   117  	wg.Add(1)
   118  	go func() {
   119  		defer wg.Done()
   120  		done := make(chan bool)
   121  		var startTime time.Time
   122  		var started, progress uint32
   123  		go func() {
   124  			s := new(string)
   125  			SetFinalizer(s, func(ss *string) {
   126  				startTime = time.Now()
   127  				atomic.StoreUint32(&started, 1)
   128  				growStack(&progress)
   129  				done <- true
   130  			})
   131  			s = nil
   132  			done <- true
   133  		}()
   134  		<-done
   135  		GC()
   136  
   137  		timeout := 20 * time.Second
   138  		if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
   139  			scale, err := strconv.Atoi(s)
   140  			if err == nil {
   141  				timeout *= time.Duration(scale)
   142  			}
   143  		}
   144  
   145  		select {
   146  		case <-done:
   147  		case <-time.After(timeout):
   148  			if atomic.LoadUint32(&started) == 0 {
   149  				t.Log("finalizer did not start")
   150  			} else {
   151  				t.Logf("finalizer started %s ago and finished %d iterations", time.Since(startTime), atomic.LoadUint32(&progress))
   152  			}
   153  			t.Log("first growStack took", growDuration)
   154  			t.Error("finalizer did not run")
   155  			return
   156  		}
   157  	}()
   158  	wg.Wait()
   159  }
   160  
   161  // ... and in init
   162  //func init() {
   163  //	growStack()
   164  //}
   165  
   166  func growStack(progress *uint32) {
   167  	n := 1 << 10
   168  	if testing.Short() {
   169  		n = 1 << 8
   170  	}
   171  	for i := 0; i < n; i++ {
   172  		x := 0
   173  		growStackIter(&x, i)
   174  		if x != i+1 {
   175  			panic("stack is corrupted")
   176  		}
   177  		if progress != nil {
   178  			atomic.StoreUint32(progress, uint32(i))
   179  		}
   180  	}
   181  	GC()
   182  }
   183  
   184  // This function is not an anonymous func, so that the compiler can do escape
   185  // analysis and place x on stack (and subsequently stack growth update the pointer).
   186  func growStackIter(p *int, n int) {
   187  	if n == 0 {
   188  		*p = n + 1
   189  		GC()
   190  		return
   191  	}
   192  	*p = n + 1
   193  	x := 0
   194  	growStackIter(&x, n-1)
   195  	if x != n {
   196  		panic("stack is corrupted")
   197  	}
   198  }
   199  
   200  func TestStackGrowthCallback(t *testing.T) {
   201  	t.Parallel()
   202  	var wg sync.WaitGroup
   203  
   204  	// test stack growth at chan op
   205  	wg.Add(1)
   206  	go func() {
   207  		defer wg.Done()
   208  		c := make(chan int, 1)
   209  		growStackWithCallback(func() {
   210  			c <- 1
   211  			<-c
   212  		})
   213  	}()
   214  
   215  	// test stack growth at map op
   216  	wg.Add(1)
   217  	go func() {
   218  		defer wg.Done()
   219  		m := make(map[int]int)
   220  		growStackWithCallback(func() {
   221  			_, _ = m[1]
   222  			m[1] = 1
   223  		})
   224  	}()
   225  
   226  	// test stack growth at goroutine creation
   227  	wg.Add(1)
   228  	go func() {
   229  		defer wg.Done()
   230  		growStackWithCallback(func() {
   231  			done := make(chan bool)
   232  			go func() {
   233  				done <- true
   234  			}()
   235  			<-done
   236  		})
   237  	}()
   238  	wg.Wait()
   239  }
   240  
   241  func growStackWithCallback(cb func()) {
   242  	var f func(n int)
   243  	f = func(n int) {
   244  		if n == 0 {
   245  			cb()
   246  			return
   247  		}
   248  		f(n - 1)
   249  	}
   250  	for i := 0; i < 1<<10; i++ {
   251  		f(i)
   252  	}
   253  }
   254  
   255  // TestDeferPtrs tests the adjustment of Defer's argument pointers (p aka &y)
   256  // during a stack copy.
   257  func set(p *int, x int) {
   258  	*p = x
   259  }
   260  func TestDeferPtrs(t *testing.T) {
   261  	var y int
   262  
   263  	defer func() {
   264  		if y != 42 {
   265  			t.Errorf("defer's stack references were not adjusted appropriately")
   266  		}
   267  	}()
   268  	defer set(&y, 42)
   269  	growStack(nil)
   270  }
   271  
   272  type bigBuf [4 * 1024]byte
   273  
   274  // TestDeferPtrsGoexit is like TestDeferPtrs but exercises the possibility that the
   275  // stack grows as part of starting the deferred function. It calls Goexit at various
   276  // stack depths, forcing the deferred function (with >4kB of args) to be run at
   277  // the bottom of the stack. The goal is to find a stack depth less than 4kB from
   278  // the end of the stack. Each trial runs in a different goroutine so that an earlier
   279  // stack growth does not invalidate a later attempt.
   280  func TestDeferPtrsGoexit(t *testing.T) {
   281  	for i := 0; i < 100; i++ {
   282  		c := make(chan int, 1)
   283  		go testDeferPtrsGoexit(c, i)
   284  		if n := <-c; n != 42 {
   285  			t.Fatalf("defer's stack references were not adjusted appropriately (i=%d n=%d)", i, n)
   286  		}
   287  	}
   288  }
   289  
   290  func testDeferPtrsGoexit(c chan int, i int) {
   291  	var y int
   292  	defer func() {
   293  		c <- y
   294  	}()
   295  	defer setBig(&y, 42, bigBuf{})
   296  	useStackAndCall(i, Goexit)
   297  }
   298  
   299  func setBig(p *int, x int, b bigBuf) {
   300  	*p = x
   301  }
   302  
   303  // TestDeferPtrsPanic is like TestDeferPtrsGoexit, but it's using panic instead
   304  // of Goexit to run the Defers. Those two are different execution paths
   305  // in the runtime.
   306  func TestDeferPtrsPanic(t *testing.T) {
   307  	for i := 0; i < 100; i++ {
   308  		c := make(chan int, 1)
   309  		go testDeferPtrsGoexit(c, i)
   310  		if n := <-c; n != 42 {
   311  			t.Fatalf("defer's stack references were not adjusted appropriately (i=%d n=%d)", i, n)
   312  		}
   313  	}
   314  }
   315  
   316  func testDeferPtrsPanic(c chan int, i int) {
   317  	var y int
   318  	defer func() {
   319  		if recover() == nil {
   320  			c <- -1
   321  			return
   322  		}
   323  		c <- y
   324  	}()
   325  	defer setBig(&y, 42, bigBuf{})
   326  	useStackAndCall(i, func() { panic(1) })
   327  }
   328  
   329  //go:noinline
   330  func testDeferLeafSigpanic1() {
   331  	// Cause a sigpanic to be injected in this frame.
   332  	//
   333  	// This function has to be declared before
   334  	// TestDeferLeafSigpanic so the runtime will crash if we think
   335  	// this function's continuation PC is in
   336  	// TestDeferLeafSigpanic.
   337  	*(*int)(nil) = 0
   338  }
   339  
   340  // TestDeferLeafSigpanic tests defer matching around leaf functions
   341  // that sigpanic. This is tricky because on LR machines the outer
   342  // function and the inner function have the same SP, but it's critical
   343  // that we match up the defer correctly to get the right liveness map.
   344  // See issue #25499.
   345  func TestDeferLeafSigpanic(t *testing.T) {
   346  	// Push a defer that will walk the stack.
   347  	defer func() {
   348  		if err := recover(); err == nil {
   349  			t.Fatal("expected panic from nil pointer")
   350  		}
   351  		GC()
   352  	}()
   353  	// Call a leaf function. We must set up the exact call stack:
   354  	//
   355  	//  defering function -> leaf function -> sigpanic
   356  	//
   357  	// On LR machines, the leaf function will have the same SP as
   358  	// the SP pushed for the defer frame.
   359  	testDeferLeafSigpanic1()
   360  }
   361  
   362  // TestPanicUseStack checks that a chain of Panic structs on the stack are
   363  // updated correctly if the stack grows during the deferred execution that
   364  // happens as a result of the panic.
   365  func TestPanicUseStack(t *testing.T) {
   366  	pc := make([]uintptr, 10000)
   367  	defer func() {
   368  		recover()
   369  		Callers(0, pc) // force stack walk
   370  		useStackAndCall(100, func() {
   371  			defer func() {
   372  				recover()
   373  				Callers(0, pc) // force stack walk
   374  				useStackAndCall(200, func() {
   375  					defer func() {
   376  						recover()
   377  						Callers(0, pc) // force stack walk
   378  					}()
   379  					panic(3)
   380  				})
   381  			}()
   382  			panic(2)
   383  		})
   384  	}()
   385  	panic(1)
   386  }
   387  
   388  func TestPanicFar(t *testing.T) {
   389  	var xtree *xtreeNode
   390  	pc := make([]uintptr, 10000)
   391  	defer func() {
   392  		// At this point we created a large stack and unwound
   393  		// it via recovery. Force a stack walk, which will
   394  		// check the stack's consistency.
   395  		Callers(0, pc)
   396  	}()
   397  	defer func() {
   398  		recover()
   399  	}()
   400  	useStackAndCall(100, func() {
   401  		// Kick off the GC and make it do something nontrivial.
   402  		// (This used to force stack barriers to stick around.)
   403  		xtree = makeTree(18)
   404  		// Give the GC time to start scanning stacks.
   405  		time.Sleep(time.Millisecond)
   406  		panic(1)
   407  	})
   408  	_ = xtree
   409  }
   410  
   411  type xtreeNode struct {
   412  	l, r *xtreeNode
   413  }
   414  
   415  func makeTree(d int) *xtreeNode {
   416  	if d == 0 {
   417  		return new(xtreeNode)
   418  	}
   419  	return &xtreeNode{makeTree(d - 1), makeTree(d - 1)}
   420  }
   421  
   422  // use about n KB of stack and call f
   423  func useStackAndCall(n int, f func()) {
   424  	if n == 0 {
   425  		f()
   426  		return
   427  	}
   428  	var b [1024]byte // makes frame about 1KB
   429  	useStackAndCall(n-1+int(b[99]), f)
   430  }
   431  
   432  func useStack(n int) {
   433  	useStackAndCall(n, func() {})
   434  }
   435  
   436  func growing(c chan int, done chan struct{}) {
   437  	for n := range c {
   438  		useStack(n)
   439  		done <- struct{}{}
   440  	}
   441  	done <- struct{}{}
   442  }
   443  
   444  func TestStackCache(t *testing.T) {
   445  	// Allocate a bunch of goroutines and grow their stacks.
   446  	// Repeat a few times to test the stack cache.
   447  	const (
   448  		R = 4
   449  		G = 200
   450  		S = 5
   451  	)
   452  	for i := 0; i < R; i++ {
   453  		var reqchans [G]chan int
   454  		done := make(chan struct{})
   455  		for j := 0; j < G; j++ {
   456  			reqchans[j] = make(chan int)
   457  			go growing(reqchans[j], done)
   458  		}
   459  		for s := 0; s < S; s++ {
   460  			for j := 0; j < G; j++ {
   461  				reqchans[j] <- 1 << uint(s)
   462  			}
   463  			for j := 0; j < G; j++ {
   464  				<-done
   465  			}
   466  		}
   467  		for j := 0; j < G; j++ {
   468  			close(reqchans[j])
   469  		}
   470  		for j := 0; j < G; j++ {
   471  			<-done
   472  		}
   473  	}
   474  }
   475  
   476  func TestStackOutput(t *testing.T) {
   477  	b := make([]byte, 1024)
   478  	stk := string(b[:Stack(b, false)])
   479  	if !strings.HasPrefix(stk, "goroutine ") {
   480  		t.Errorf("Stack (len %d):\n%s", len(stk), stk)
   481  		t.Errorf("Stack output should begin with \"goroutine \"")
   482  	}
   483  }
   484  
   485  func TestStackAllOutput(t *testing.T) {
   486  	b := make([]byte, 1024)
   487  	stk := string(b[:Stack(b, true)])
   488  	if !strings.HasPrefix(stk, "goroutine ") {
   489  		t.Errorf("Stack (len %d):\n%s", len(stk), stk)
   490  		t.Errorf("Stack output should begin with \"goroutine \"")
   491  	}
   492  }
   493  
   494  func TestStackPanic(t *testing.T) {
   495  	// Test that stack copying copies panics correctly. This is difficult
   496  	// to test because it is very unlikely that the stack will be copied
   497  	// in the middle of gopanic. But it can happen.
   498  	// To make this test effective, edit panic.go:gopanic and uncomment
   499  	// the GC() call just before freedefer(d).
   500  	defer func() {
   501  		if x := recover(); x == nil {
   502  			t.Errorf("recover failed")
   503  		}
   504  	}()
   505  	useStack(32)
   506  	panic("test panic")
   507  }
   508  
   509  func BenchmarkStackCopyPtr(b *testing.B) {
   510  	c := make(chan bool)
   511  	for i := 0; i < b.N; i++ {
   512  		go func() {
   513  			i := 1000000
   514  			countp(&i)
   515  			c <- true
   516  		}()
   517  		<-c
   518  	}
   519  }
   520  
   521  func countp(n *int) {
   522  	if *n == 0 {
   523  		return
   524  	}
   525  	*n--
   526  	countp(n)
   527  }
   528  
   529  func BenchmarkStackCopy(b *testing.B) {
   530  	c := make(chan bool)
   531  	for i := 0; i < b.N; i++ {
   532  		go func() {
   533  			count(1000000)
   534  			c <- true
   535  		}()
   536  		<-c
   537  	}
   538  }
   539  
   540  func count(n int) int {
   541  	if n == 0 {
   542  		return 0
   543  	}
   544  	return 1 + count(n-1)
   545  }
   546  
   547  func BenchmarkStackCopyNoCache(b *testing.B) {
   548  	c := make(chan bool)
   549  	for i := 0; i < b.N; i++ {
   550  		go func() {
   551  			count1(1000000)
   552  			c <- true
   553  		}()
   554  		<-c
   555  	}
   556  }
   557  
   558  func count1(n int) int {
   559  	if n <= 0 {
   560  		return 0
   561  	}
   562  	return 1 + count2(n-1)
   563  }
   564  
   565  func count2(n int) int  { return 1 + count3(n-1) }
   566  func count3(n int) int  { return 1 + count4(n-1) }
   567  func count4(n int) int  { return 1 + count5(n-1) }
   568  func count5(n int) int  { return 1 + count6(n-1) }
   569  func count6(n int) int  { return 1 + count7(n-1) }
   570  func count7(n int) int  { return 1 + count8(n-1) }
   571  func count8(n int) int  { return 1 + count9(n-1) }
   572  func count9(n int) int  { return 1 + count10(n-1) }
   573  func count10(n int) int { return 1 + count11(n-1) }
   574  func count11(n int) int { return 1 + count12(n-1) }
   575  func count12(n int) int { return 1 + count13(n-1) }
   576  func count13(n int) int { return 1 + count14(n-1) }
   577  func count14(n int) int { return 1 + count15(n-1) }
   578  func count15(n int) int { return 1 + count16(n-1) }
   579  func count16(n int) int { return 1 + count17(n-1) }
   580  func count17(n int) int { return 1 + count18(n-1) }
   581  func count18(n int) int { return 1 + count19(n-1) }
   582  func count19(n int) int { return 1 + count20(n-1) }
   583  func count20(n int) int { return 1 + count21(n-1) }
   584  func count21(n int) int { return 1 + count22(n-1) }
   585  func count22(n int) int { return 1 + count23(n-1) }
   586  func count23(n int) int { return 1 + count1(n-1) }
   587  
   588  type structWithMethod struct{}
   589  
   590  func (s structWithMethod) caller() string {
   591  	_, file, line, ok := Caller(1)
   592  	if !ok {
   593  		panic("Caller failed")
   594  	}
   595  	return fmt.Sprintf("%s:%d", file, line)
   596  }
   597  
   598  func (s structWithMethod) callers() []uintptr {
   599  	pc := make([]uintptr, 16)
   600  	return pc[:Callers(0, pc)]
   601  }
   602  
   603  func (s structWithMethod) stack() string {
   604  	buf := make([]byte, 4<<10)
   605  	return string(buf[:Stack(buf, false)])
   606  }
   607  
   608  func (s structWithMethod) nop() {}
   609  
   610  func TestStackWrapperCaller(t *testing.T) {
   611  	var d structWithMethod
   612  	// Force the compiler to construct a wrapper method.
   613  	wrapper := (*structWithMethod).caller
   614  	// Check that the wrapper doesn't affect the stack trace.
   615  	if dc, ic := d.caller(), wrapper(&d); dc != ic {
   616  		t.Fatalf("direct caller %q != indirect caller %q", dc, ic)
   617  	}
   618  }
   619  
   620  func TestStackWrapperCallers(t *testing.T) {
   621  	var d structWithMethod
   622  	wrapper := (*structWithMethod).callers
   623  	// Check that <autogenerated> doesn't appear in the stack trace.
   624  	pcs := wrapper(&d)
   625  	frames := CallersFrames(pcs)
   626  	for {
   627  		fr, more := frames.Next()
   628  		if fr.File == "<autogenerated>" {
   629  			t.Fatalf("<autogenerated> appears in stack trace: %+v", fr)
   630  		}
   631  		if !more {
   632  			break
   633  		}
   634  	}
   635  }
   636  
   637  func TestStackWrapperStack(t *testing.T) {
   638  	var d structWithMethod
   639  	wrapper := (*structWithMethod).stack
   640  	// Check that <autogenerated> doesn't appear in the stack trace.
   641  	stk := wrapper(&d)
   642  	if strings.Contains(stk, "<autogenerated>") {
   643  		t.Fatalf("<autogenerated> appears in stack trace:\n%s", stk)
   644  	}
   645  }
   646  
   647  type I interface {
   648  	M()
   649  }
   650  
   651  func TestStackWrapperStackPanic(t *testing.T) {
   652  	t.Run("sigpanic", func(t *testing.T) {
   653  		// nil calls to interface methods cause a sigpanic.
   654  		testStackWrapperPanic(t, func() { I.M(nil) }, "runtime_test.I.M")
   655  	})
   656  	t.Run("panicwrap", func(t *testing.T) {
   657  		// Nil calls to value method wrappers call panicwrap.
   658  		wrapper := (*structWithMethod).nop
   659  		testStackWrapperPanic(t, func() { wrapper(nil) }, "runtime_test.(*structWithMethod).nop")
   660  	})
   661  }
   662  
   663  func testStackWrapperPanic(t *testing.T, cb func(), expect string) {
   664  	// Test that the stack trace from a panicking wrapper includes
   665  	// the wrapper, even though elide these when they don't panic.
   666  	t.Run("CallersFrames", func(t *testing.T) {
   667  		defer func() {
   668  			err := recover()
   669  			if err == nil {
   670  				t.Fatalf("expected panic")
   671  			}
   672  			pcs := make([]uintptr, 10)
   673  			n := Callers(0, pcs)
   674  			frames := CallersFrames(pcs[:n])
   675  			for {
   676  				frame, more := frames.Next()
   677  				t.Log(frame.Function)
   678  				if frame.Function == expect {
   679  					return
   680  				}
   681  				if !more {
   682  					break
   683  				}
   684  			}
   685  			t.Fatalf("panicking wrapper %s missing from stack trace", expect)
   686  		}()
   687  		cb()
   688  	})
   689  	t.Run("Stack", func(t *testing.T) {
   690  		defer func() {
   691  			err := recover()
   692  			if err == nil {
   693  				t.Fatalf("expected panic")
   694  			}
   695  			buf := make([]byte, 4<<10)
   696  			stk := string(buf[:Stack(buf, false)])
   697  			if !strings.Contains(stk, "\n"+expect) {
   698  				t.Fatalf("panicking wrapper %s missing from stack trace:\n%s", expect, stk)
   699  			}
   700  		}()
   701  		cb()
   702  	})
   703  }
   704  
   705  func TestCallersFromWrapper(t *testing.T) {
   706  	// Test that invoking CallersFrames on a stack where the first
   707  	// PC is an autogenerated wrapper keeps the wrapper in the
   708  	// trace. Normally we elide these, assuming that the wrapper
   709  	// calls the thing you actually wanted to see, but in this
   710  	// case we need to keep it.
   711  	pc := reflect.ValueOf(I.M).Pointer()
   712  	frames := CallersFrames([]uintptr{pc})
   713  	frame, more := frames.Next()
   714  	if frame.Function != "runtime_test.I.M" {
   715  		t.Fatalf("want function %s, got %s", "runtime_test.I.M", frame.Function)
   716  	}
   717  	if more {
   718  		t.Fatalf("want 1 frame, got > 1")
   719  	}
   720  }
   721  
   722  func TestTracebackSystemstack(t *testing.T) {
   723  	if GOARCH == "ppc64" || GOARCH == "ppc64le" {
   724  		t.Skip("systemstack tail call not implemented on ppc64x")
   725  	}
   726  
   727  	// Test that profiles correctly jump over systemstack,
   728  	// including nested systemstack calls.
   729  	pcs := make([]uintptr, 20)
   730  	pcs = pcs[:TracebackSystemstack(pcs, 5)]
   731  	// Check that runtime.TracebackSystemstack appears five times
   732  	// and that we see TestTracebackSystemstack.
   733  	countIn, countOut := 0, 0
   734  	frames := CallersFrames(pcs)
   735  	var tb bytes.Buffer
   736  	for {
   737  		frame, more := frames.Next()
   738  		fmt.Fprintf(&tb, "\n%s+0x%x %s:%d", frame.Function, frame.PC-frame.Entry, frame.File, frame.Line)
   739  		switch frame.Function {
   740  		case "runtime.TracebackSystemstack":
   741  			countIn++
   742  		case "runtime_test.TestTracebackSystemstack":
   743  			countOut++
   744  		}
   745  		if !more {
   746  			break
   747  		}
   748  	}
   749  	if countIn != 5 || countOut != 1 {
   750  		t.Fatalf("expected 5 calls to TracebackSystemstack and 1 call to TestTracebackSystemstack, got:%s", tb.String())
   751  	}
   752  }
   753  
   754  func TestTracebackAncestors(t *testing.T) {
   755  	goroutineRegex := regexp.MustCompile(`goroutine [0-9]+ \[`)
   756  	for _, tracebackDepth := range []int{0, 1, 5, 50} {
   757  		output := runTestProg(t, "testprog", "TracebackAncestors", fmt.Sprintf("GODEBUG=tracebackancestors=%d", tracebackDepth))
   758  
   759  		numGoroutines := 3
   760  		numFrames := 2
   761  		ancestorsExpected := numGoroutines
   762  		if numGoroutines > tracebackDepth {
   763  			ancestorsExpected = tracebackDepth
   764  		}
   765  
   766  		matches := goroutineRegex.FindAllStringSubmatch(output, -1)
   767  		if len(matches) != 2 {
   768  			t.Fatalf("want 2 goroutines, got:\n%s", output)
   769  		}
   770  
   771  		// Check functions in the traceback.
   772  		fns := []string{"main.recurseThenCallGo", "main.main", "main.printStack", "main.TracebackAncestors"}
   773  		for _, fn := range fns {
   774  			if !strings.Contains(output, "\n"+fn+"(") {
   775  				t.Fatalf("expected %q function in traceback:\n%s", fn, output)
   776  			}
   777  		}
   778  
   779  		if want, count := "originating from goroutine", ancestorsExpected; strings.Count(output, want) != count {
   780  			t.Errorf("output does not contain %d instances of %q:\n%s", count, want, output)
   781  		}
   782  
   783  		if want, count := "main.recurseThenCallGo(...)", ancestorsExpected*(numFrames+1); strings.Count(output, want) != count {
   784  			t.Errorf("output does not contain %d instances of %q:\n%s", count, want, output)
   785  		}
   786  
   787  		if want, count := "main.recurseThenCallGo(0x", 1; strings.Count(output, want) != count {
   788  			t.Errorf("output does not contain %d instances of %q:\n%s", count, want, output)
   789  		}
   790  	}
   791  }
   792  
   793  // Test that defer closure is correctly scanned when the stack is scanned.
   794  func TestDeferLiveness(t *testing.T) {
   795  	output := runTestProg(t, "testprog", "DeferLiveness", "GODEBUG=clobberfree=1")
   796  	if output != "" {
   797  		t.Errorf("output:\n%s\n\nwant no output", output)
   798  	}
   799  }
   800  
   801  func TestDeferHeapAndStack(t *testing.T) {
   802  	P := 4     // processors
   803  	N := 10000 //iterations
   804  	D := 200   // stack depth
   805  
   806  	if testing.Short() {
   807  		P /= 2
   808  		N /= 10
   809  		D /= 10
   810  	}
   811  	c := make(chan bool)
   812  	for p := 0; p < P; p++ {
   813  		go func() {
   814  			for i := 0; i < N; i++ {
   815  				if deferHeapAndStack(D) != 2*D {
   816  					panic("bad result")
   817  				}
   818  			}
   819  			c <- true
   820  		}()
   821  	}
   822  	for p := 0; p < P; p++ {
   823  		<-c
   824  	}
   825  }
   826  
   827  // deferHeapAndStack(n) computes 2*n
   828  func deferHeapAndStack(n int) (r int) {
   829  	if n == 0 {
   830  		return 0
   831  	}
   832  	if n%2 == 0 {
   833  		// heap-allocated defers
   834  		for i := 0; i < 2; i++ {
   835  			defer func() {
   836  				r++
   837  			}()
   838  		}
   839  	} else {
   840  		// stack-allocated defers
   841  		defer func() {
   842  			r++
   843  		}()
   844  		defer func() {
   845  			r++
   846  		}()
   847  	}
   848  	r = deferHeapAndStack(n - 1)
   849  	escapeMe(new([1024]byte)) // force some GCs
   850  	return
   851  }
   852  
   853  // Pass a value to escapeMe to force it to escape.
   854  var escapeMe = func(x interface{}) {}
   855  
   856  // Test that when F -> G is inlined and F is excluded from stack
   857  // traces, G still appears.
   858  func TestTracebackInlineExcluded(t *testing.T) {
   859  	defer func() {
   860  		recover()
   861  		buf := make([]byte, 4<<10)
   862  		stk := string(buf[:Stack(buf, false)])
   863  
   864  		t.Log(stk)
   865  
   866  		if not := "tracebackExcluded"; strings.Contains(stk, not) {
   867  			t.Errorf("found but did not expect %q", not)
   868  		}
   869  		if want := "tracebackNotExcluded"; !strings.Contains(stk, want) {
   870  			t.Errorf("expected %q in stack", want)
   871  		}
   872  	}()
   873  	tracebackExcluded()
   874  }
   875  
   876  // tracebackExcluded should be excluded from tracebacks. There are
   877  // various ways this could come up. Linking it to a "runtime." name is
   878  // rather synthetic, but it's easy and reliable. See issue #42754 for
   879  // one way this happened in real code.
   880  //
   881  //go:linkname tracebackExcluded runtime.tracebackExcluded
   882  //go:noinline
   883  func tracebackExcluded() {
   884  	// Call an inlined function that should not itself be excluded
   885  	// from tracebacks.
   886  	tracebackNotExcluded()
   887  }
   888  
   889  // tracebackNotExcluded should be inlined into tracebackExcluded, but
   890  // should not itself be excluded from the traceback.
   891  func tracebackNotExcluded() {
   892  	var x *int
   893  	*x = 0
   894  }
   895  

View as plain text