src/runtime/stack_test.go - go - Git at Google

 // Copyright 2012 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 (
 	"bytes"
 	"fmt"
 	"os"
 	"reflect"
 	"regexp"
 	. "runtime"
 	"strconv"
 	"strings"
 	"sync"
 	"sync/atomic"
 	"testing"
 	"time"
 )

 // TestStackMem measures per-thread stack segment cache behavior.
 // The test consumed up to 500MB in the past.
 func TestStackMem(t *testing.T) {
 	const (
 		BatchSize      = 32
 		BatchCount     = 256
 		ArraySize      = 1024
 		RecursionDepth = 128
 	)
 	if testing.Short() {
 		return
 	}
 	defer GOMAXPROCS(GOMAXPROCS(BatchSize))
 	s0 := new(MemStats)
 	ReadMemStats(s0)
 	for b := 0; b < BatchCount; b++ {
 		c := make(chan bool, BatchSize)
 		for i := 0; i < BatchSize; i++ {
 			go func() {
 				var f func(k int, a [ArraySize]byte)
 				f = func(k int, a [ArraySize]byte) {
 					if k == 0 {
 						time.Sleep(time.Millisecond)
 						return
 					}
 					f(k-1, a)
 				}
 				f(RecursionDepth, [ArraySize]byte{})
 				c <- true
 			}()
 		}
 		for i := 0; i < BatchSize; i++ {
 			<-c
 		}

 		// The goroutines have signaled via c that they are ready to exit.
 		// Give them a chance to exit by sleeping. If we don't wait, we
 		// might not reuse them on the next batch.
 		time.Sleep(10 * time.Millisecond)
 	}
 	s1 := new(MemStats)
 	ReadMemStats(s1)
 	consumed := int64(s1.StackSys - s0.StackSys)
 	t.Logf("Consumed %vMB for stack mem", consumed>>20)
 	estimate := int64(8 * BatchSize * ArraySize * RecursionDepth) // 8 is to reduce flakiness.
 	if consumed > estimate {
 		t.Fatalf("Stack mem: want %v, got %v", estimate, consumed)
 	}
 	// Due to broken stack memory accounting (https://golang.org/issue/7468),
 	// StackInuse can decrease during function execution, so we cast the values to int64.
 	inuse := int64(s1.StackInuse) - int64(s0.StackInuse)
 	t.Logf("Inuse %vMB for stack mem", inuse>>20)
 	if inuse > 4<<20 {
 		t.Fatalf("Stack inuse: want %v, got %v", 4<<20, inuse)
 	}
 }

 // Test stack growing in different contexts.
 func TestStackGrowth(t *testing.T) {
 	if *flagQuick {
 		t.Skip("-quick")
 	}

 	if GOARCH == "wasm" {
 		t.Skip("fails on wasm (too slow?)")
 	}

 	// Don't make this test parallel as this makes the 20 second
 	// timeout unreliable on slow builders. (See issue #19381.)

 	var wg sync.WaitGroup

 	// in a normal goroutine
 	var growDuration time.Duration // For debugging failures
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		start := time.Now()
 		growStack(nil)
 		growDuration = time.Since(start)
 	}()
 	wg.Wait()

 	// in locked goroutine
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		LockOSThread()
 		growStack(nil)
 		UnlockOSThread()
 	}()
 	wg.Wait()

 	// in finalizer
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		done := make(chan bool)
 		var startTime time.Time
 		var started, progress uint32
 		go func() {
 			s := new(string)
 			SetFinalizer(s, func(ss *string) {
 				startTime = time.Now()
 				atomic.StoreUint32(&started, 1)
 				growStack(&progress)
 				done <- true
 			})
 			s = nil
 			done <- true
 		}()
 		<-done
 		GC()

 		timeout := 20 * time.Second
 		if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
 			scale, err := strconv.Atoi(s)
 			if err == nil {
 				timeout *= time.Duration(scale)
 			}
 		}

 		select {
 		case <-done:
 		case <-time.After(timeout):
 			if atomic.LoadUint32(&started) == 0 {
 				t.Log("finalizer did not start")
 			} else {
 				t.Logf("finalizer started %s ago and finished %d iterations", time.Since(startTime), atomic.LoadUint32(&progress))
 			}
 			t.Log("first growStack took", growDuration)
 			t.Error("finalizer did not run")
 			return
 		}
 	}()
 	wg.Wait()
 }

 // ... and in init
 //func init() {
 //	growStack()
 //}

 func growStack(progress *uint32) {
 	n := 1 << 10
 	if testing.Short() {
 		n = 1 << 8
 	}
 	for i := 0; i < n; i++ {
 		x := 0
 		growStackIter(&x, i)
 		if x != i+1 {
 			panic("stack is corrupted")
 		}
 		if progress != nil {
 			atomic.StoreUint32(progress, uint32(i))
 		}
 	}
 	GC()
 }

 // This function is not an anonymous func, so that the compiler can do escape
 // analysis and place x on stack (and subsequently stack growth update the pointer).
 func growStackIter(p *int, n int) {
 	if n == 0 {
 		*p = n + 1
 		GC()
 		return
 	}
 	*p = n + 1
 	x := 0
 	growStackIter(&x, n-1)
 	if x != n {
 		panic("stack is corrupted")
 	}
 }

 func TestStackGrowthCallback(t *testing.T) {
 	t.Parallel()
 	var wg sync.WaitGroup

 	// test stack growth at chan op
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		c := make(chan int, 1)
 		growStackWithCallback(func() {
 			c <- 1
 			<-c
 		})
 	}()

 	// test stack growth at map op
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		m := make(map[int]int)
 		growStackWithCallback(func() {
 			_, _ = m[1]
 			m[1] = 1
 		})
 	}()

 	// test stack growth at goroutine creation
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		growStackWithCallback(func() {
 			done := make(chan bool)
 			go func() {
 				done <- true
 			}()
 			<-done
 		})
 	}()
 	wg.Wait()
 }

 func growStackWithCallback(cb func()) {
 	var f func(n int)
 	f = func(n int) {
 		if n == 0 {
 			cb()
 			return
 		}
 		f(n - 1)
 	}
 	for i := 0; i < 1<<10; i++ {
 		f(i)
 	}
 }

 // TestDeferPtrs tests the adjustment of Defer's argument pointers (p aka &y)
 // during a stack copy.
 func set(p *int, x int) {
 	*p = x
 }
 func TestDeferPtrs(t *testing.T) {
 	var y int

 	defer func() {
 		if y != 42 {
 			t.Errorf("defer's stack references were not adjusted appropriately")
 		}
 	}()
 	defer set(&y, 42)
 	growStack(nil)
 }

 type bigBuf [4 * 1024]byte

 // TestDeferPtrsGoexit is like TestDeferPtrs but exercises the possibility that the
 // stack grows as part of starting the deferred function. It calls Goexit at various
 // stack depths, forcing the deferred function (with >4kB of args) to be run at
 // the bottom of the stack. The goal is to find a stack depth less than 4kB from
 // the end of the stack. Each trial runs in a different goroutine so that an earlier
 // stack growth does not invalidate a later attempt.
 func TestDeferPtrsGoexit(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		c := make(chan int, 1)
 		go testDeferPtrsGoexit(c, i)
 		if n := <-c; n != 42 {
 			t.Fatalf("defer's stack references were not adjusted appropriately (i=%d n=%d)", i, n)
 		}
 	}
 }

 func testDeferPtrsGoexit(c chan int, i int) {
 	var y int
 	defer func() {
 		c <- y
 	}()
 	defer setBig(&y, 42, bigBuf{})
 	useStackAndCall(i, Goexit)
 }

 func setBig(p *int, x int, b bigBuf) {
 	*p = x
 }

 // TestDeferPtrsPanic is like TestDeferPtrsGoexit, but it's using panic instead
 // of Goexit to run the Defers. Those two are different execution paths
 // in the runtime.
 func TestDeferPtrsPanic(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		c := make(chan int, 1)
 		go testDeferPtrsGoexit(c, i)
 		if n := <-c; n != 42 {
 			t.Fatalf("defer's stack references were not adjusted appropriately (i=%d n=%d)", i, n)
 		}
 	}
 }

 func testDeferPtrsPanic(c chan int, i int) {
 	var y int
 	defer func() {
 		if recover() == nil {
 			c <- -1
 			return
 		}
 		c <- y
 	}()
 	defer setBig(&y, 42, bigBuf{})
 	useStackAndCall(i, func() { panic(1) })
 }

 //go:noinline
 func testDeferLeafSigpanic1() {
 	// Cause a sigpanic to be injected in this frame.
 	//
 	// This function has to be declared before
 	// TestDeferLeafSigpanic so the runtime will crash if we think
 	// this function's continuation PC is in
 	// TestDeferLeafSigpanic.
 	*(*int)(nil) = 0
 }

 // TestDeferLeafSigpanic tests defer matching around leaf functions
 // that sigpanic. This is tricky because on LR machines the outer
 // function and the inner function have the same SP, but it's critical
 // that we match up the defer correctly to get the right liveness map.
 // See issue #25499.
 func TestDeferLeafSigpanic(t *testing.T) {
 	// Push a defer that will walk the stack.
 	defer func() {
 		if err := recover(); err == nil {
 			t.Fatal("expected panic from nil pointer")
 		}
 		GC()
 	}()
 	// Call a leaf function. We must set up the exact call stack:
 	//
 	//  defering function -> leaf function -> sigpanic
 	//
 	// On LR machines, the leaf function will have the same SP as
 	// the SP pushed for the defer frame.
 	testDeferLeafSigpanic1()
 }

 // TestPanicUseStack checks that a chain of Panic structs on the stack are
 // updated correctly if the stack grows during the deferred execution that
 // happens as a result of the panic.
 func TestPanicUseStack(t *testing.T) {
 	pc := make([]uintptr, 10000)
 	defer func() {
 		recover()
 		Callers(0, pc) // force stack walk
 		useStackAndCall(100, func() {
 			defer func() {
 				recover()
 				Callers(0, pc) // force stack walk
 				useStackAndCall(200, func() {
 					defer func() {
 						recover()
 						Callers(0, pc) // force stack walk
 					}()
 					panic(3)
 				})
 			}()
 			panic(2)
 		})
 	}()
 	panic(1)
 }

 func TestPanicFar(t *testing.T) {
 	var xtree *xtreeNode
 	pc := make([]uintptr, 10000)
 	defer func() {
 		// At this point we created a large stack and unwound
 		// it via recovery. Force a stack walk, which will
 		// check the stack's consistency.
 		Callers(0, pc)
 	}()
 	defer func() {
 		recover()
 	}()
 	useStackAndCall(100, func() {
 		// Kick off the GC and make it do something nontrivial.
 		// (This used to force stack barriers to stick around.)
 		xtree = makeTree(18)
 		// Give the GC time to start scanning stacks.
 		time.Sleep(time.Millisecond)
 		panic(1)
 	})
 	_ = xtree
 }

 type xtreeNode struct {
 	l, r *xtreeNode
 }

 func makeTree(d int) *xtreeNode {
 	if d == 0 {
 		return new(xtreeNode)
 	}
 	return &xtreeNode{makeTree(d - 1), makeTree(d - 1)}
 }

 // use about n KB of stack and call f
 func useStackAndCall(n int, f func()) {
 	if n == 0 {
 		f()
 		return
 	}
 	var b [1024]byte // makes frame about 1KB
 	useStackAndCall(n-1+int(b[99]), f)
 }

 func useStack(n int) {
 	useStackAndCall(n, func() {})
 }

 func growing(c chan int, done chan struct{}) {
 	for n := range c {
 		useStack(n)
 		done <- struct{}{}
 	}
 	done <- struct{}{}
 }

 func TestStackCache(t *testing.T) {
 	// Allocate a bunch of goroutines and grow their stacks.
 	// Repeat a few times to test the stack cache.
 	const (
 		R = 4
 		G = 200
 		S = 5
 	)
 	for i := 0; i < R; i++ {
 		var reqchans [G]chan int
 		done := make(chan struct{})
 		for j := 0; j < G; j++ {
 			reqchans[j] = make(chan int)
 			go growing(reqchans[j], done)
 		}
 		for s := 0; s < S; s++ {
 			for j := 0; j < G; j++ {
 				reqchans[j] <- 1 << uint(s)
 			}
 			for j := 0; j < G; j++ {
 				<-done
 			}
 		}
 		for j := 0; j < G; j++ {
 			close(reqchans[j])
 		}
 		for j := 0; j < G; j++ {
 			<-done
 		}
 	}
 }

 func TestStackOutput(t *testing.T) {
 	b := make([]byte, 1024)
 	stk := string(b[:Stack(b, false)])
 	if !strings.HasPrefix(stk, "goroutine ") {
 		t.Errorf("Stack (len %d):\n%s", len(stk), stk)
 		t.Errorf("Stack output should begin with \"goroutine \"")
 	}
 }

 func TestStackAllOutput(t *testing.T) {
 	b := make([]byte, 1024)
 	stk := string(b[:Stack(b, true)])
 	if !strings.HasPrefix(stk, "goroutine ") {
 		t.Errorf("Stack (len %d):\n%s", len(stk), stk)
 		t.Errorf("Stack output should begin with \"goroutine \"")
 	}
 }

 func TestStackPanic(t *testing.T) {
 	// Test that stack copying copies panics correctly. This is difficult
 	// to test because it is very unlikely that the stack will be copied
 	// in the middle of gopanic. But it can happen.
 	// To make this test effective, edit panic.go:gopanic and uncomment
 	// the GC() call just before freedefer(d).
 	defer func() {
 		if x := recover(); x == nil {
 			t.Errorf("recover failed")
 		}
 	}()
 	useStack(32)
 	panic("test panic")
 }

 func BenchmarkStackCopyPtr(b *testing.B) {
 	c := make(chan bool)
 	for i := 0; i < b.N; i++ {
 		go func() {
 			i := 1000000
 			countp(&i)
 			c <- true
 		}()
 		<-c
 	}
 }

 func countp(n *int) {
 	if *n == 0 {
 		return
 	}
 	*n--
 	countp(n)
 }

 func BenchmarkStackCopy(b *testing.B) {
 	c := make(chan bool)
 	for i := 0; i < b.N; i++ {
 		go func() {
 			count(1000000)
 			c <- true
 		}()
 		<-c
 	}
 }

 func count(n int) int {
 	if n == 0 {
 		return 0
 	}
 	return 1 + count(n-1)
 }

 func BenchmarkStackCopyNoCache(b *testing.B) {
 	c := make(chan bool)
 	for i := 0; i < b.N; i++ {
 		go func() {
 			count1(1000000)
 			c <- true
 		}()
 		<-c
 	}
 }

 func count1(n int) int {
 	if n <= 0 {
 		return 0
 	}
 	return 1 + count2(n-1)
 }

 func count2(n int) int  { return 1 + count3(n-1) }
 func count3(n int) int  { return 1 + count4(n-1) }
 func count4(n int) int  { return 1 + count5(n-1) }
 func count5(n int) int  { return 1 + count6(n-1) }
 func count6(n int) int  { return 1 + count7(n-1) }
 func count7(n int) int  { return 1 + count8(n-1) }
 func count8(n int) int  { return 1 + count9(n-1) }
 func count9(n int) int  { return 1 + count10(n-1) }
 func count10(n int) int { return 1 + count11(n-1) }
 func count11(n int) int { return 1 + count12(n-1) }
 func count12(n int) int { return 1 + count13(n-1) }
 func count13(n int) int { return 1 + count14(n-1) }
 func count14(n int) int { return 1 + count15(n-1) }
 func count15(n int) int { return 1 + count16(n-1) }
 func count16(n int) int { return 1 + count17(n-1) }
 func count17(n int) int { return 1 + count18(n-1) }
 func count18(n int) int { return 1 + count19(n-1) }
 func count19(n int) int { return 1 + count20(n-1) }
 func count20(n int) int { return 1 + count21(n-1) }
 func count21(n int) int { return 1 + count22(n-1) }
 func count22(n int) int { return 1 + count23(n-1) }
 func count23(n int) int { return 1 + count1(n-1) }

 type structWithMethod struct{}

 func (s structWithMethod) caller() string {
 	_, file, line, ok := Caller(1)
 	if !ok {
 		panic("Caller failed")
 	}
 	return fmt.Sprintf("%s:%d", file, line)
 }

 func (s structWithMethod) callers() []uintptr {
 	pc := make([]uintptr, 16)
 	return pc[:Callers(0, pc)]
 }

 func (s structWithMethod) stack() string {
 	buf := make([]byte, 4<<10)
 	return string(buf[:Stack(buf, false)])
 }

 func (s structWithMethod) nop() {}

 func TestStackWrapperCaller(t *testing.T) {
 	var d structWithMethod
 	// Force the compiler to construct a wrapper method.
 	wrapper := (*structWithMethod).caller
 	// Check that the wrapper doesn't affect the stack trace.
 	if dc, ic := d.caller(), wrapper(&d); dc != ic {
 		t.Fatalf("direct caller %q != indirect caller %q", dc, ic)
 	}
 }

 func TestStackWrapperCallers(t *testing.T) {
 	var d structWithMethod
 	wrapper := (*structWithMethod).callers
 	// Check that <autogenerated> doesn't appear in the stack trace.
 	pcs := wrapper(&d)
 	frames := CallersFrames(pcs)
 	for {
 		fr, more := frames.Next()
 		if fr.File == "<autogenerated>" {
 			t.Fatalf("<autogenerated> appears in stack trace: %+v", fr)
 		}
 		if !more {
 			break
 		}
 	}
 }

 func TestStackWrapperStack(t *testing.T) {
 	var d structWithMethod
 	wrapper := (*structWithMethod).stack
 	// Check that <autogenerated> doesn't appear in the stack trace.
 	stk := wrapper(&d)
 	if strings.Contains(stk, "<autogenerated>") {
 		t.Fatalf("<autogenerated> appears in stack trace:\n%s", stk)
 	}
 }

 type I interface {
 	M()
 }

 func TestStackWrapperStackPanic(t *testing.T) {
 	t.Run("sigpanic", func(t *testing.T) {
 		// nil calls to interface methods cause a sigpanic.
 		testStackWrapperPanic(t, func() { I.M(nil) }, "runtime_test.I.M")
 	})
 	t.Run("panicwrap", func(t *testing.T) {
 		// Nil calls to value method wrappers call panicwrap.
 		wrapper := (*structWithMethod).nop
 		testStackWrapperPanic(t, func() { wrapper(nil) }, "runtime_test.(*structWithMethod).nop")
 	})
 }

 func testStackWrapperPanic(t *testing.T, cb func(), expect string) {
 	// Test that the stack trace from a panicking wrapper includes
 	// the wrapper, even though elide these when they don't panic.
 	t.Run("CallersFrames", func(t *testing.T) {
 		defer func() {
 			err := recover()
 			if err == nil {
 				t.Fatalf("expected panic")
 			}
 			pcs := make([]uintptr, 10)
 			n := Callers(0, pcs)
 			frames := CallersFrames(pcs[:n])
 			for {
 				frame, more := frames.Next()
 				t.Log(frame.Function)
 				if frame.Function == expect {
 					return
 				}
 				if !more {
 					break
 				}
 			}
 			t.Fatalf("panicking wrapper %s missing from stack trace", expect)
 		}()
 		cb()
 	})
 	t.Run("Stack", func(t *testing.T) {
 		defer func() {
 			err := recover()
 			if err == nil {
 				t.Fatalf("expected panic")
 			}
 			buf := make([]byte, 4<<10)
 			stk := string(buf[:Stack(buf, false)])
 			if !strings.Contains(stk, "\n"+expect) {
 				t.Fatalf("panicking wrapper %s missing from stack trace:\n%s", expect, stk)
 			}
 		}()
 		cb()
 	})
 }

 func TestCallersFromWrapper(t *testing.T) {
 	// Test that invoking CallersFrames on a stack where the first
 	// PC is an autogenerated wrapper keeps the wrapper in the
 	// trace. Normally we elide these, assuming that the wrapper
 	// calls the thing you actually wanted to see, but in this
 	// case we need to keep it.
 	pc := reflect.ValueOf(I.M).Pointer()
 	frames := CallersFrames([]uintptr{pc})
 	frame, more := frames.Next()
 	if frame.Function != "runtime_test.I.M" {
 		t.Fatalf("want function %s, got %s", "runtime_test.I.M", frame.Function)
 	}
 	if more {
 		t.Fatalf("want 1 frame, got > 1")
 	}
 }

 func TestTracebackSystemstack(t *testing.T) {
 	if GOARCH == "ppc64" || GOARCH == "ppc64le" {
 		t.Skip("systemstack tail call not implemented on ppc64x")
 	}

 	// Test that profiles correctly jump over systemstack,
 	// including nested systemstack calls.
 	pcs := make([]uintptr, 20)
 	pcs = pcs[:TracebackSystemstack(pcs, 5)]
 	// Check that runtime.TracebackSystemstack appears five times
 	// and that we see TestTracebackSystemstack.
 	countIn, countOut := 0, 0
 	frames := CallersFrames(pcs)
 	var tb bytes.Buffer
 	for {
 		frame, more := frames.Next()
 		fmt.Fprintf(&tb, "\n%s+0x%x %s:%d", frame.Function, frame.PC-frame.Entry, frame.File, frame.Line)
 		switch frame.Function {
 		case "runtime.TracebackSystemstack":
 			countIn++
 		case "runtime_test.TestTracebackSystemstack":
 			countOut++
 		}
 		if !more {
 			break
 		}
 	}
 	if countIn != 5 || countOut != 1 {
 		t.Fatalf("expected 5 calls to TracebackSystemstack and 1 call to TestTracebackSystemstack, got:%s", tb.String())
 	}
 }

 func TestTracebackAncestors(t *testing.T) {
 	goroutineRegex := regexp.MustCompile(`goroutine [0-9]+ \[`)
 	for _, tracebackDepth := range []int{0, 1, 5, 50} {
 		output := runTestProg(t, "testprog", "TracebackAncestors", fmt.Sprintf("GODEBUG=tracebackancestors=%d", tracebackDepth))

 		numGoroutines := 3
 		numFrames := 2
 		ancestorsExpected := numGoroutines
 		if numGoroutines > tracebackDepth {
 			ancestorsExpected = tracebackDepth
 		}

 		matches := goroutineRegex.FindAllStringSubmatch(output, -1)
 		if len(matches) != 2 {
 			t.Fatalf("want 2 goroutines, got:\n%s", output)
 		}

 		// Check functions in the traceback.
 		fns := []string{"main.recurseThenCallGo", "main.main", "main.printStack", "main.TracebackAncestors"}
 		for _, fn := range fns {
 			if !strings.Contains(output, "\n"+fn+"(") {
 				t.Fatalf("expected %q function in traceback:\n%s", fn, output)
 			}
 		}

 		if want, count := "originating from goroutine", ancestorsExpected; strings.Count(output, want) != count {
 			t.Errorf("output does not contain %d instances of %q:\n%s", count, want, output)
 		}

 		if want, count := "main.recurseThenCallGo(...)", ancestorsExpected*(numFrames+1); strings.Count(output, want) != count {
 			t.Errorf("output does not contain %d instances of %q:\n%s", count, want, output)
 		}

 		if want, count := "main.recurseThenCallGo(0x", 1; strings.Count(output, want) != count {
 			t.Errorf("output does not contain %d instances of %q:\n%s", count, want, output)
 		}
 	}
 }

 // Test that defer closure is correctly scanned when the stack is scanned.
 func TestDeferLiveness(t *testing.T) {
 	output := runTestProg(t, "testprog", "DeferLiveness", "GODEBUG=clobberfree=1")
 	if output != "" {
 		t.Errorf("output:\n%s\n\nwant no output", output)
 	}
 }

 func TestDeferHeapAndStack(t *testing.T) {
 	P := 4     // processors
 	N := 10000 //iterations
 	D := 200   // stack depth

 	if testing.Short() {
 		P /= 2
 		N /= 10
 		D /= 10
 	}
 	c := make(chan bool)
 	for p := 0; p < P; p++ {
 		go func() {
 			for i := 0; i < N; i++ {
 				if deferHeapAndStack(D) != 2*D {
 					panic("bad result")
 				}
 			}
 			c <- true
 		}()
 	}
 	for p := 0; p < P; p++ {
 		<-c
 	}
 }

 // deferHeapAndStack(n) computes 2*n
 func deferHeapAndStack(n int) (r int) {
 	if n == 0 {
 		return 0
 	}
 	if n%2 == 0 {
 		// heap-allocated defers
 		for i := 0; i < 2; i++ {
 			defer func() {
 				r++
 			}()
 		}
 	} else {
 		// stack-allocated defers
 		defer func() {
 			r++
 		}()
 		defer func() {
 			r++
 		}()
 	}
 	r = deferHeapAndStack(n - 1)
 	escapeMe(new([1024]byte)) // force some GCs
 	return
 }

 // Pass a value to escapeMe to force it to escape.
 var escapeMe = func(x interface{}) {}
	// Copyright 2012 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 (
	"bytes"
	"fmt"
	"os"
	"reflect"
	"regexp"
	. "runtime"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"
	)

	// TestStackMem measures per-thread stack segment cache behavior.
	// The test consumed up to 500MB in the past.
	func TestStackMem(t *testing.T) {
	const (
	BatchSize = 32
	BatchCount = 256
	ArraySize = 1024
	RecursionDepth = 128
	)
	if testing.Short() {
	return
	}
	defer GOMAXPROCS(GOMAXPROCS(BatchSize))
	s0 := new(MemStats)
	ReadMemStats(s0)
	for b := 0; b < BatchCount; b++ {
	c := make(chan bool, BatchSize)
	for i := 0; i < BatchSize; i++ {
	go func() {
	var f func(k int, a [ArraySize]byte)
	f = func(k int, a [ArraySize]byte) {
	if k == 0 {
	time.Sleep(time.Millisecond)
	return
	}
	f(k-1, a)
	}
	f(RecursionDepth, [ArraySize]byte{})
	c <- true
	}()
	}
	for i := 0; i < BatchSize; i++ {
	<-c
	}

	// The goroutines have signaled via c that they are ready to exit.
	// Give them a chance to exit by sleeping. If we don't wait, we
	// might not reuse them on the next batch.
	time.Sleep(10 * time.Millisecond)
	}
	s1 := new(MemStats)
	ReadMemStats(s1)
	consumed := int64(s1.StackSys - s0.StackSys)
	t.Logf("Consumed %vMB for stack mem", consumed>>20)
	estimate := int64(8 * BatchSize * ArraySize * RecursionDepth) // 8 is to reduce flakiness.
	if consumed > estimate {
	t.Fatalf("Stack mem: want %v, got %v", estimate, consumed)
	}
	// Due to broken stack memory accounting (https://golang.org/issue/7468),
	// StackInuse can decrease during function execution, so we cast the values to int64.
	inuse := int64(s1.StackInuse) - int64(s0.StackInuse)
	t.Logf("Inuse %vMB for stack mem", inuse>>20)
	if inuse > 4<<20 {
	t.Fatalf("Stack inuse: want %v, got %v", 4<<20, inuse)
	}
	}

	// Test stack growing in different contexts.
	func TestStackGrowth(t *testing.T) {
	if *flagQuick {
	t.Skip("-quick")
	}

	if GOARCH == "wasm" {
	t.Skip("fails on wasm (too slow?)")
	}

	// Don't make this test parallel as this makes the 20 second
	// timeout unreliable on slow builders. (See issue #19381.)

	var wg sync.WaitGroup

	// in a normal goroutine
	var growDuration time.Duration // For debugging failures
	wg.Add(1)
	go func() {
	defer wg.Done()
	start := time.Now()
	growStack(nil)
	growDuration = time.Since(start)
	}()
	wg.Wait()

	// in locked goroutine
	wg.Add(1)
	go func() {
	defer wg.Done()
	LockOSThread()
	growStack(nil)
	UnlockOSThread()
	}()
	wg.Wait()

	// in finalizer
	wg.Add(1)
	go func() {
	defer wg.Done()
	done := make(chan bool)
	var startTime time.Time
	var started, progress uint32
	go func() {
	s := new(string)
	SetFinalizer(s, func(ss *string) {
	startTime = time.Now()
	atomic.StoreUint32(&started, 1)
	growStack(&progress)
	done <- true
	})
	s = nil
	done <- true
	}()
	<-done
	GC()

	timeout := 20 * time.Second
	if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
	scale, err := strconv.Atoi(s)
	if err == nil {
	timeout *= time.Duration(scale)
	}
	}

	select {
	case <-done:
	case <-time.After(timeout):
	if atomic.LoadUint32(&started) == 0 {
	t.Log("finalizer did not start")
	} else {
	t.Logf("finalizer started %s ago and finished %d iterations", time.Since(startTime), atomic.LoadUint32(&progress))
	}
	t.Log("first growStack took", growDuration)
	t.Error("finalizer did not run")
	return
	}
	}()
	wg.Wait()
	}

	// ... and in init
	//func init() {
	// growStack()
	//}

	func growStack(progress *uint32) {
	n := 1 << 10
	if testing.Short() {
	n = 1 << 8
	}
	for i := 0; i < n; i++ {
	x := 0
	growStackIter(&x, i)
	if x != i+1 {
	panic("stack is corrupted")
	}
	if progress != nil {
	atomic.StoreUint32(progress, uint32(i))
	}
	}
	GC()
	}

	// This function is not an anonymous func, so that the compiler can do escape
	// analysis and place x on stack (and subsequently stack growth update the pointer).
	func growStackIter(p *int, n int) {
	if n == 0 {
	*p = n + 1
	GC()
	return
	}
	*p = n + 1
	x := 0
	growStackIter(&x, n-1)
	if x != n {
	panic("stack is corrupted")
	}
	}

	func TestStackGrowthCallback(t *testing.T) {
	t.Parallel()
	var wg sync.WaitGroup

	// test stack growth at chan op
	wg.Add(1)
	go func() {
	defer wg.Done()
	c := make(chan int, 1)
	growStackWithCallback(func() {
	c <- 1
	<-c
	})
	}()

	// test stack growth at map op
	wg.Add(1)
	go func() {
	defer wg.Done()
	m := make(map[int]int)
	growStackWithCallback(func() {
	_, _ = m[1]
	m[1] = 1
	})
	}()

	// test stack growth at goroutine creation
	wg.Add(1)
	go func() {
	defer wg.Done()
	growStackWithCallback(func() {
	done := make(chan bool)
	go func() {
	done <- true
	}()
	<-done
	})
	}()
	wg.Wait()
	}

	func growStackWithCallback(cb func()) {
	var f func(n int)
	f = func(n int) {
	if n == 0 {
	cb()
	return
	}
	f(n - 1)
	}
	for i := 0; i < 1<<10; i++ {
	f(i)
	}
	}

	// TestDeferPtrs tests the adjustment of Defer's argument pointers (p aka &y)
	// during a stack copy.
	func set(p *int, x int) {
	*p = x
	}
	func TestDeferPtrs(t *testing.T) {
	var y int

	defer func() {
	if y != 42 {
	t.Errorf("defer's stack references were not adjusted appropriately")
	}
	}()
	defer set(&y, 42)
	growStack(nil)
	}

	type bigBuf [4 * 1024]byte

	// TestDeferPtrsGoexit is like TestDeferPtrs but exercises the possibility that the
	// stack grows as part of starting the deferred function. It calls Goexit at various
	// stack depths, forcing the deferred function (with >4kB of args) to be run at
	// the bottom of the stack. The goal is to find a stack depth less than 4kB from
	// the end of the stack. Each trial runs in a different goroutine so that an earlier
	// stack growth does not invalidate a later attempt.
	func TestDeferPtrsGoexit(t *testing.T) {
	for i := 0; i < 100; i++ {
	c := make(chan int, 1)
	go testDeferPtrsGoexit(c, i)
	if n := <-c; n != 42 {
	t.Fatalf("defer's stack references were not adjusted appropriately (i=%d n=%d)", i, n)
	}
	}
	}

	func testDeferPtrsGoexit(c chan int, i int) {
	var y int
	defer func() {
	c <- y
	}()
	defer setBig(&y, 42, bigBuf{})
	useStackAndCall(i, Goexit)
	}

	func setBig(p *int, x int, b bigBuf) {
	*p = x
	}

	// TestDeferPtrsPanic is like TestDeferPtrsGoexit, but it's using panic instead
	// of Goexit to run the Defers. Those two are different execution paths
	// in the runtime.
	func TestDeferPtrsPanic(t *testing.T) {
	for i := 0; i < 100; i++ {
	c := make(chan int, 1)
	go testDeferPtrsGoexit(c, i)
	if n := <-c; n != 42 {
	t.Fatalf("defer's stack references were not adjusted appropriately (i=%d n=%d)", i, n)
	}
	}
	}

	func testDeferPtrsPanic(c chan int, i int) {
	var y int
	defer func() {
	if recover() == nil {
	c <- -1
	return
	}
	c <- y
	}()
	defer setBig(&y, 42, bigBuf{})
	useStackAndCall(i, func() { panic(1) })
	}

	//go:noinline
	func testDeferLeafSigpanic1() {
	// Cause a sigpanic to be injected in this frame.
	//
	// This function has to be declared before
	// TestDeferLeafSigpanic so the runtime will crash if we think
	// this function's continuation PC is in
	// TestDeferLeafSigpanic.
	(int)(nil) = 0
	}

	// TestDeferLeafSigpanic tests defer matching around leaf functions
	// that sigpanic. This is tricky because on LR machines the outer
	// function and the inner function have the same SP, but it's critical
	// that we match up the defer correctly to get the right liveness map.
	// See issue #25499.
	func TestDeferLeafSigpanic(t *testing.T) {
	// Push a defer that will walk the stack.
	defer func() {
	if err := recover(); err == nil {
	t.Fatal("expected panic from nil pointer")
	}
	GC()
	}()
	// Call a leaf function. We must set up the exact call stack:
	//
	// defering function -> leaf function -> sigpanic
	//
	// On LR machines, the leaf function will have the same SP as
	// the SP pushed for the defer frame.
	testDeferLeafSigpanic1()
	}

	// TestPanicUseStack checks that a chain of Panic structs on the stack are
	// updated correctly if the stack grows during the deferred execution that
	// happens as a result of the panic.
	func TestPanicUseStack(t *testing.T) {
	pc := make([]uintptr, 10000)
	defer func() {
	recover()
	Callers(0, pc) // force stack walk
	useStackAndCall(100, func() {
	defer func() {
	recover()
	Callers(0, pc) // force stack walk
	useStackAndCall(200, func() {
	defer func() {
	recover()
	Callers(0, pc) // force stack walk
	}()
	panic(3)
	})
	}()
	panic(2)
	})
	}()
	panic(1)
	}

	func TestPanicFar(t *testing.T) {
	var xtree *xtreeNode
	pc := make([]uintptr, 10000)
	defer func() {
	// At this point we created a large stack and unwound
	// it via recovery. Force a stack walk, which will
	// check the stack's consistency.
	Callers(0, pc)
	}()
	defer func() {
	recover()
	}()
	useStackAndCall(100, func() {
	// Kick off the GC and make it do something nontrivial.
	// (This used to force stack barriers to stick around.)
	xtree = makeTree(18)
	// Give the GC time to start scanning stacks.
	time.Sleep(time.Millisecond)
	panic(1)
	})
	_ = xtree
	}

	type xtreeNode struct {
	l, r *xtreeNode
	}

	func makeTree(d int) *xtreeNode {
	if d == 0 {
	return new(xtreeNode)
	}
	return &xtreeNode{makeTree(d - 1), makeTree(d - 1)}
	}

	// use about n KB of stack and call f
	func useStackAndCall(n int, f func()) {
	if n == 0 {
	f()
	return
	}
	var b [1024]byte // makes frame about 1KB
	useStackAndCall(n-1+int(b[99]), f)
	}

	func useStack(n int) {
	useStackAndCall(n, func() {})
	}

	func growing(c chan int, done chan struct{}) {
	for n := range c {
	useStack(n)
	done <- struct{}{}
	}
	done <- struct{}{}
	}

	func TestStackCache(t *testing.T) {
	// Allocate a bunch of goroutines and grow their stacks.
	// Repeat a few times to test the stack cache.
	const (
	R = 4
	G = 200
	S = 5
	)
	for i := 0; i < R; i++ {
	var reqchans [G]chan int
	done := make(chan struct{})
	for j := 0; j < G; j++ {
	reqchans[j] = make(chan int)
	go growing(reqchans[j], done)
	}
	for s := 0; s < S; s++ {
	for j := 0; j < G; j++ {
	reqchans[j] <- 1 << uint(s)
	}
	for j := 0; j < G; j++ {
	<-done
	}
	}
	for j := 0; j < G; j++ {
	close(reqchans[j])
	}
	for j := 0; j < G; j++ {
	<-done
	}
	}
	}

	func TestStackOutput(t *testing.T) {
	b := make([]byte, 1024)
	stk := string(b[:Stack(b, false)])
	if !strings.HasPrefix(stk, "goroutine ") {
	t.Errorf("Stack (len %d):\n%s", len(stk), stk)
	t.Errorf("Stack output should begin with \"goroutine \"")
	}
	}

	func TestStackAllOutput(t *testing.T) {
	b := make([]byte, 1024)
	stk := string(b[:Stack(b, true)])
	if !strings.HasPrefix(stk, "goroutine ") {
	t.Errorf("Stack (len %d):\n%s", len(stk), stk)
	t.Errorf("Stack output should begin with \"goroutine \"")
	}
	}

	func TestStackPanic(t *testing.T) {
	// Test that stack copying copies panics correctly. This is difficult
	// to test because it is very unlikely that the stack will be copied
	// in the middle of gopanic. But it can happen.
	// To make this test effective, edit panic.go:gopanic and uncomment
	// the GC() call just before freedefer(d).
	defer func() {
	if x := recover(); x == nil {
	t.Errorf("recover failed")
	}
	}()
	useStack(32)
	panic("test panic")
	}

	func BenchmarkStackCopyPtr(b *testing.B) {
	c := make(chan bool)
	for i := 0; i < b.N; i++ {
	go func() {
	i := 1000000
	countp(&i)
	c <- true
	}()
	<-c
	}
	}

	func countp(n *int) {
	if *n == 0 {
	return
	}
	*n--
	countp(n)
	}

	func BenchmarkStackCopy(b *testing.B) {
	c := make(chan bool)
	for i := 0; i < b.N; i++ {
	go func() {
	count(1000000)
	c <- true
	}()
	<-c
	}
	}

	func count(n int) int {
	if n == 0 {
	return 0
	}
	return 1 + count(n-1)
	}

	func BenchmarkStackCopyNoCache(b *testing.B) {
	c := make(chan bool)
	for i := 0; i < b.N; i++ {
	go func() {
	count1(1000000)
	c <- true
	}()
	<-c
	}
	}

	func count1(n int) int {
	if n <= 0 {
	return 0
	}
	return 1 + count2(n-1)
	}

	func count2(n int) int { return 1 + count3(n-1) }
	func count3(n int) int { return 1 + count4(n-1) }
	func count4(n int) int { return 1 + count5(n-1) }
	func count5(n int) int { return 1 + count6(n-1) }
	func count6(n int) int { return 1 + count7(n-1) }
	func count7(n int) int { return 1 + count8(n-1) }
	func count8(n int) int { return 1 + count9(n-1) }
	func count9(n int) int { return 1 + count10(n-1) }
	func count10(n int) int { return 1 + count11(n-1) }
	func count11(n int) int { return 1 + count12(n-1) }
	func count12(n int) int { return 1 + count13(n-1) }
	func count13(n int) int { return 1 + count14(n-1) }
	func count14(n int) int { return 1 + count15(n-1) }
	func count15(n int) int { return 1 + count16(n-1) }
	func count16(n int) int { return 1 + count17(n-1) }
	func count17(n int) int { return 1 + count18(n-1) }
	func count18(n int) int { return 1 + count19(n-1) }
	func count19(n int) int { return 1 + count20(n-1) }
	func count20(n int) int { return 1 + count21(n-1) }
	func count21(n int) int { return 1 + count22(n-1) }
	func count22(n int) int { return 1 + count23(n-1) }
	func count23(n int) int { return 1 + count1(n-1) }

	type structWithMethod struct{}

	func (s structWithMethod) caller() string {
	_, file, line, ok := Caller(1)
	if !ok {
	panic("Caller failed")
	}
	return fmt.Sprintf("%s:%d", file, line)
	}

	func (s structWithMethod) callers() []uintptr {
	pc := make([]uintptr, 16)
	return pc[:Callers(0, pc)]
	}

	func (s structWithMethod) stack() string {
	buf := make([]byte, 4<<10)
	return string(buf[:Stack(buf, false)])
	}

	func (s structWithMethod) nop() {}

	func TestStackWrapperCaller(t *testing.T) {
	var d structWithMethod
	// Force the compiler to construct a wrapper method.
	wrapper := (*structWithMethod).caller
	// Check that the wrapper doesn't affect the stack trace.
	if dc, ic := d.caller(), wrapper(&d); dc != ic {
	t.Fatalf("direct caller %q != indirect caller %q", dc, ic)
	}
	}

	func TestStackWrapperCallers(t *testing.T) {
	var d structWithMethod
	wrapper := (*structWithMethod).callers
	// Check that <autogenerated> doesn't appear in the stack trace.
	pcs := wrapper(&d)
	frames := CallersFrames(pcs)
	for {
	fr, more := frames.Next()
	if fr.File == "<autogenerated>" {
	t.Fatalf("<autogenerated> appears in stack trace: %+v", fr)
	}
	if !more {
	break
	}
	}
	}

	func TestStackWrapperStack(t *testing.T) {
	var d structWithMethod
	wrapper := (*structWithMethod).stack
	// Check that <autogenerated> doesn't appear in the stack trace.
	stk := wrapper(&d)
	if strings.Contains(stk, "<autogenerated>") {
	t.Fatalf("<autogenerated> appears in stack trace:\n%s", stk)
	}
	}

	type I interface {
	M()
	}

	func TestStackWrapperStackPanic(t *testing.T) {
	t.Run("sigpanic", func(t *testing.T) {
	// nil calls to interface methods cause a sigpanic.
	testStackWrapperPanic(t, func() { I.M(nil) }, "runtime_test.I.M")
	})
	t.Run("panicwrap", func(t *testing.T) {
	// Nil calls to value method wrappers call panicwrap.
	wrapper := (*structWithMethod).nop
	testStackWrapperPanic(t, func() { wrapper(nil) }, "runtime_test.(*structWithMethod).nop")
	})
	}

	func testStackWrapperPanic(t *testing.T, cb func(), expect string) {
	// Test that the stack trace from a panicking wrapper includes
	// the wrapper, even though elide these when they don't panic.
	t.Run("CallersFrames", func(t *testing.T) {
	defer func() {
	err := recover()
	if err == nil {
	t.Fatalf("expected panic")
	}
	pcs := make([]uintptr, 10)
	n := Callers(0, pcs)
	frames := CallersFrames(pcs[:n])
	for {
	frame, more := frames.Next()
	t.Log(frame.Function)
	if frame.Function == expect {
	return
	}
	if !more {
	break
	}
	}
	t.Fatalf("panicking wrapper %s missing from stack trace", expect)
	}()
	cb()
	})
	t.Run("Stack", func(t *testing.T) {
	defer func() {
	err := recover()
	if err == nil {
	t.Fatalf("expected panic")
	}
	buf := make([]byte, 4<<10)
	stk := string(buf[:Stack(buf, false)])
	if !strings.Contains(stk, "\n"+expect) {
	t.Fatalf("panicking wrapper %s missing from stack trace:\n%s", expect, stk)
	}
	}()
	cb()
	})
	}

	func TestCallersFromWrapper(t *testing.T) {
	// Test that invoking CallersFrames on a stack where the first
	// PC is an autogenerated wrapper keeps the wrapper in the
	// trace. Normally we elide these, assuming that the wrapper
	// calls the thing you actually wanted to see, but in this
	// case we need to keep it.
	pc := reflect.ValueOf(I.M).Pointer()
	frames := CallersFrames([]uintptr{pc})
	frame, more := frames.Next()
	if frame.Function != "runtime_test.I.M" {
	t.Fatalf("want function %s, got %s", "runtime_test.I.M", frame.Function)
	}
	if more {
	t.Fatalf("want 1 frame, got > 1")
	}
	}

	func TestTracebackSystemstack(t *testing.T) {
	if GOARCH == "ppc64" \|\| GOARCH == "ppc64le" {
	t.Skip("systemstack tail call not implemented on ppc64x")
	}

	// Test that profiles correctly jump over systemstack,
	// including nested systemstack calls.
	pcs := make([]uintptr, 20)
	pcs = pcs[:TracebackSystemstack(pcs, 5)]
	// Check that runtime.TracebackSystemstack appears five times
	// and that we see TestTracebackSystemstack.
	countIn, countOut := 0, 0
	frames := CallersFrames(pcs)
	var tb bytes.Buffer
	for {
	frame, more := frames.Next()
	fmt.Fprintf(&tb, "\n%s+0x%x %s:%d", frame.Function, frame.PC-frame.Entry, frame.File, frame.Line)
	switch frame.Function {
	case "runtime.TracebackSystemstack":
	countIn++
	case "runtime_test.TestTracebackSystemstack":
	countOut++
	}
	if !more {
	break
	}
	}
	if countIn != 5 \|\| countOut != 1 {
	t.Fatalf("expected 5 calls to TracebackSystemstack and 1 call to TestTracebackSystemstack, got:%s", tb.String())
	}
	}

	func TestTracebackAncestors(t *testing.T) {
	goroutineRegex := regexp.MustCompile(`goroutine [0-9]+ \[`)
	for _, tracebackDepth := range []int{0, 1, 5, 50} {
	output := runTestProg(t, "testprog", "TracebackAncestors", fmt.Sprintf("GODEBUG=tracebackancestors=%d", tracebackDepth))

	numGoroutines := 3
	numFrames := 2
	ancestorsExpected := numGoroutines
	if numGoroutines > tracebackDepth {
	ancestorsExpected = tracebackDepth
	}

	matches := goroutineRegex.FindAllStringSubmatch(output, -1)
	if len(matches) != 2 {
	t.Fatalf("want 2 goroutines, got:\n%s", output)
	}

	// Check functions in the traceback.
	fns := []string{"main.recurseThenCallGo", "main.main", "main.printStack", "main.TracebackAncestors"}
	for _, fn := range fns {
	if !strings.Contains(output, "\n"+fn+"(") {
	t.Fatalf("expected %q function in traceback:\n%s", fn, output)
	}
	}

	if want, count := "originating from goroutine", ancestorsExpected; strings.Count(output, want) != count {
	t.Errorf("output does not contain %d instances of %q:\n%s", count, want, output)
	}

	if want, count := "main.recurseThenCallGo(...)", ancestorsExpected*(numFrames+1); strings.Count(output, want) != count {
	t.Errorf("output does not contain %d instances of %q:\n%s", count, want, output)
	}

	if want, count := "main.recurseThenCallGo(0x", 1; strings.Count(output, want) != count {
	t.Errorf("output does not contain %d instances of %q:\n%s", count, want, output)
	}
	}
	}

	// Test that defer closure is correctly scanned when the stack is scanned.
	func TestDeferLiveness(t *testing.T) {
	output := runTestProg(t, "testprog", "DeferLiveness", "GODEBUG=clobberfree=1")
	if output != "" {
	t.Errorf("output:\n%s\n\nwant no output", output)
	}
	}

	func TestDeferHeapAndStack(t *testing.T) {
	P := 4 // processors
	N := 10000 //iterations
	D := 200 // stack depth

	if testing.Short() {
	P /= 2
	N /= 10
	D /= 10
	}
	c := make(chan bool)
	for p := 0; p < P; p++ {
	go func() {
	for i := 0; i < N; i++ {
	if deferHeapAndStack(D) != 2*D {
	panic("bad result")
	}
	}
	c <- true
	}()
	}
	for p := 0; p < P; p++ {
	<-c
	}
	}

	// deferHeapAndStack(n) computes 2*n
	func deferHeapAndStack(n int) (r int) {
	if n == 0 {
	return 0
	}
	if n%2 == 0 {
	// heap-allocated defers
	for i := 0; i < 2; i++ {
	defer func() {
	r++
	}()
	}
	} else {
	// stack-allocated defers
	defer func() {
	r++
	}()
	defer func() {
	r++
	}()
	}
	r = deferHeapAndStack(n - 1)
	escapeMe(new([1024]byte)) // force some GCs
	return
	}

	// Pass a value to escapeMe to force it to escape.
	var escapeMe = func(x interface{}) {}