libgo patch committed: copy rdebug code from Go 1.7

Ian Lance Taylor iant@golang.org
Mon Oct 17 16:54:00 GMT 2016


This patch to libgo copies the rdebug code from the Go 1.7 runtime to libgo.

While we're at it, this updates the runtime/debug package, and starts
running its testsuite by default.  I'm not sure why runtime/debug was
not previously updated to 1.7.  Doing that led me to fix some minor
aspects of runtime.Stack and the C function runtime/debug.readGCStats.

Bootstrapped and ran Go testsuite on x86_64-pc-linux-gnu.  Committed
to mainline.

Ian
-------------- next part --------------
Index: gcc/go/gofrontend/MERGE
===================================================================
--- gcc/go/gofrontend/MERGE	(revision 241197)
+++ gcc/go/gofrontend/MERGE	(working copy)
@@ -1,4 +1,4 @@
-880cb0a45590d992880fc6aabc7484e54c817eeb
+314ba28067383516c213ba84c931f93325a48c39
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.
Index: libgo/Makefile.am
===================================================================
--- libgo/Makefile.am	(revision 241197)
+++ libgo/Makefile.am	(working copy)
@@ -515,7 +515,6 @@ runtime_files = \
 	lfstack.c \
 	malloc.c \
 	netpoll.c \
-	rdebug.c \
 	reflect.c \
 	runtime1.c \
 	sigqueue.c \
@@ -3035,6 +3034,7 @@ TEST_PACKAGES = \
 	os/user/check \
 	path/filepath/check \
 	regexp/syntax/check \
+	runtime/debug/check \
 	runtime/pprof/check \
 	runtime/internal/atomic/check \
 	runtime/internal/sys/check \
Index: libgo/go/runtime/debug/garbage.go
===================================================================
--- libgo/go/runtime/debug/garbage.go	(revision 240942)
+++ libgo/go/runtime/debug/garbage.go	(working copy)
@@ -16,17 +16,10 @@ type GCStats struct {
 	NumGC          int64           // number of garbage collections
 	PauseTotal     time.Duration   // total pause for all collections
 	Pause          []time.Duration // pause history, most recent first
+	PauseEnd       []time.Time     // pause end times history, most recent first
 	PauseQuantiles []time.Duration
 }
 
-// Implemented in package runtime.
-func readGCStats(*[]time.Duration)
-func enableGC(bool) bool
-func setGCPercent(int) int
-func freeOSMemory()
-func setMaxStack(int) int
-func setMaxThreads(int) int
-
 // ReadGCStats reads statistics about garbage collection into stats.
 // The number of entries in the pause history is system-dependent;
 // stats.Pause slice will be reused if large enough, reallocated otherwise.
@@ -38,25 +31,36 @@ func setMaxThreads(int) int
 func ReadGCStats(stats *GCStats) {
 	// Create a buffer with space for at least two copies of the
 	// pause history tracked by the runtime. One will be returned
-	// to the caller and the other will be used as a temporary buffer
-	// for computing quantiles.
+	// to the caller and the other will be used as transfer buffer
+	// for end times history and as a temporary buffer for
+	// computing quantiles.
 	const maxPause = len(((*runtime.MemStats)(nil)).PauseNs)
-	if cap(stats.Pause) < 2*maxPause {
-		stats.Pause = make([]time.Duration, 2*maxPause)
+	if cap(stats.Pause) < 2*maxPause+3 {
+		stats.Pause = make([]time.Duration, 2*maxPause+3)
 	}
 
-	// readGCStats fills in the pause history (up to maxPause entries)
-	// and then three more: Unix ns time of last GC, number of GC,
-	// and total pause time in nanoseconds. Here we depend on the
-	// fact that time.Duration's native unit is nanoseconds, so the
-	// pauses and the total pause time do not need any conversion.
+	// readGCStats fills in the pause and end times histories (up to
+	// maxPause entries) and then three more: Unix ns time of last GC,
+	// number of GC, and total pause time in nanoseconds. Here we
+	// depend on the fact that time.Duration's native unit is
+	// nanoseconds, so the pauses and the total pause time do not need
+	// any conversion.
 	readGCStats(&stats.Pause)
 	n := len(stats.Pause) - 3
 	stats.LastGC = time.Unix(0, int64(stats.Pause[n]))
 	stats.NumGC = int64(stats.Pause[n+1])
 	stats.PauseTotal = stats.Pause[n+2]
+	n /= 2 // buffer holds pauses and end times
 	stats.Pause = stats.Pause[:n]
 
+	if cap(stats.PauseEnd) < maxPause {
+		stats.PauseEnd = make([]time.Time, 0, maxPause)
+	}
+	stats.PauseEnd = stats.PauseEnd[:0]
+	for _, ns := range stats.Pause[n : n+n] {
+		stats.PauseEnd = append(stats.PauseEnd, time.Unix(0, int64(ns)))
+	}
+
 	if len(stats.PauseQuantiles) > 0 {
 		if n == 0 {
 			for i := range stats.PauseQuantiles {
@@ -91,9 +95,9 @@ func (x byDuration) Less(i, j int) bool
 // at startup, or 100 if the variable is not set.
 // A negative percentage disables garbage collection.
 func SetGCPercent(percent int) int {
-	old := setGCPercent(percent)
+	old := setGCPercent(int32(percent))
 	runtime.GC()
-	return old
+	return int(old)
 }
 
 // FreeOSMemory forces a garbage collection followed by an
@@ -145,7 +149,9 @@ func SetMaxThreads(threads int) int {
 // that the runtime trigger only a panic, not a crash.
 // SetPanicOnFault applies only to the current goroutine.
 // It returns the previous setting.
-func SetPanicOnFault(enabled bool) bool
+func SetPanicOnFault(enabled bool) bool {
+	return setPanicOnFault(enabled)
+}
 
 // WriteHeapDump writes a description of the heap and the objects in
 // it to the given file descriptor.
Index: libgo/go/runtime/debug/garbage_test.go
===================================================================
--- libgo/go/runtime/debug/garbage_test.go	(revision 240942)
+++ libgo/go/runtime/debug/garbage_test.go	(working copy)
@@ -71,6 +71,19 @@ func TestReadGCStats(t *testing.T) {
 			t.Errorf("stats.PauseQuantiles[%d]=%d > stats.PauseQuantiles[%d]=%d", i, q[i], i+1, q[i+1])
 		}
 	}
+
+	// compare memory stats with gc stats:
+	if len(stats.PauseEnd) != n {
+		t.Fatalf("len(stats.PauseEnd) = %d, want %d", len(stats.PauseEnd), n)
+	}
+	off := (int(mstats.NumGC) + len(mstats.PauseEnd) - 1) % len(mstats.PauseEnd)
+	for i := 0; i < n; i++ {
+		dt := stats.PauseEnd[i]
+		if dt.UnixNano() != int64(mstats.PauseEnd[off]) {
+			t.Errorf("stats.PauseEnd[%d] = %d, want %d", i, dt, mstats.PauseEnd[off])
+		}
+		off = (off + len(mstats.PauseEnd) - 1) % len(mstats.PauseEnd)
+	}
 }
 
 var big = make([]byte, 1<<20)
Index: libgo/go/runtime/debug/stack_test.go
===================================================================
--- libgo/go/runtime/debug/stack_test.go	(revision 240942)
+++ libgo/go/runtime/debug/stack_test.go	(working copy)
@@ -50,10 +50,12 @@ func TestStack(t *testing.T) {
 		check(t, lines[n], line)
 		n++
 	}
-	frame("stack_test.go", "\tmethod.N15_runtime_debug.T: return Stack()")
-	frame("stack_test.go", "\tmethod.N15_runtime_debug.T: return t.ptrmethod()")
-	frame("stack_test.go", "\tTestStack: b := T(0).method()")
-	frame("testing/testing.go", "")
+	n++
+	frame("stack.go", "runtime_debug.Stack")
+	frame("stack_test.go", "ptrmethod")
+	frame("stack_test.go", "method")
+	frame("stack_test.go", "runtime_debug_test.TestStack")
+	frame("testing.go", "")
 }
 
 func check(t *testing.T, line, has string) {
Index: libgo/go/runtime/debug/stubs.go
===================================================================
--- libgo/go/runtime/debug/stubs.go	(revision 0)
+++ libgo/go/runtime/debug/stubs.go	(working copy)
@@ -0,0 +1,17 @@
+// Copyright 2014 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 debug
+
+import (
+	"time"
+)
+
+// Implemented in package runtime.
+func readGCStats(*[]time.Duration)
+func freeOSMemory()
+func setMaxStack(int) int
+func setGCPercent(int32) int32
+func setPanicOnFault(bool) bool
+func setMaxThreads(int) int
Index: libgo/go/runtime/mprof.go
===================================================================
--- libgo/go/runtime/mprof.go	(revision 241189)
+++ libgo/go/runtime/mprof.go	(working copy)
@@ -623,7 +623,7 @@ func Stack(buf []byte, all bool) int {
 		gp.m.traceback = 1
 		gp.writebuf = buf[0:0:len(buf)]
 		goroutineheader(gp)
-		traceback()
+		traceback(1)
 		if all {
 			tracebackothers(gp)
 		}
@@ -653,7 +653,7 @@ func tracealloc(p unsafe.Pointer, size u
 	}
 	if gp.m.curg == nil || gp == gp.m.curg {
 		goroutineheader(gp)
-		traceback()
+		traceback(1)
 	} else {
 		goroutineheader(gp.m.curg)
 		// FIXME: Can't do traceback of other g.
@@ -669,7 +669,7 @@ func tracefree(p unsafe.Pointer, size ui
 	gp.m.traceback = 2
 	print("tracefree(", p, ", ", hex(size), ")\n")
 	goroutineheader(gp)
-	traceback()
+	traceback(1)
 	print("\n")
 	gp.m.traceback = 0
 	unlock(&tracelock)
Index: libgo/go/runtime/rdebug.go
===================================================================
--- libgo/go/runtime/rdebug.go	(revision 0)
+++ libgo/go/runtime/rdebug.go	(working copy)
@@ -0,0 +1,27 @@
+// Copyright 2014 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
+
+import _ "unsafe" // for go:linkname
+
+// Define maxstacksize here for gccgo. For gc it is defined in
+// stack.go, but gccgo doesn't use that file. Or, for that matter,
+// maxstacksize.
+var maxstacksize uintptr = 1 << 20 // enough until runtime.main sets it for real
+
+//go:linkname setMaxStack runtime_debug.setMaxStack
+func setMaxStack(in int) (out int) {
+	out = int(maxstacksize)
+	maxstacksize = uintptr(in)
+	return out
+}
+
+//go:linkname setPanicOnFault runtime_debug.setPanicOnFault
+func setPanicOnFault(new bool) (old bool) {
+	_g_ := getg()
+	old = _g_.paniconfault
+	_g_.paniconfault = new
+	return old
+}
Index: libgo/go/runtime/stubs.go
===================================================================
--- libgo/go/runtime/stubs.go	(revision 241197)
+++ libgo/go/runtime/stubs.go	(working copy)
@@ -444,3 +444,19 @@ func setprofilebucket(p unsafe.Pointer,
 
 // Currently in proc.c.
 func tracebackothers(*g)
+
+// Temporary for gccgo until we port mgc.go.
+func setgcpercent(int32) int32
+
+//go:linkname setGCPercent runtime_debug.setGCPercent
+func setGCPercent(in int32) (out int32) {
+	return setgcpercent(in)
+}
+
+// Temporary for gccgo until we port proc.go.
+func setmaxthreads(int) int
+
+//go:linkname setMaxThreads runtime_debug.setMaxThreads
+func setMaxThreads(in int) (out int) {
+	return setmaxthreads(in)
+}
Index: libgo/go/runtime/traceback_gccgo.go
===================================================================
--- libgo/go/runtime/traceback_gccgo.go	(revision 241189)
+++ libgo/go/runtime/traceback_gccgo.go	(working copy)
@@ -67,9 +67,9 @@ func callers(skip int, locbuf []location
 // traceback prints a traceback of the current goroutine.
 // This differs from the gc version, which is given pc, sp, lr and g and
 // can print a traceback of any goroutine.
-func traceback() {
+func traceback(skip int32) {
 	var locbuf [100]location
-	c := c_callers(1, &locbuf[0], int32(len(locbuf)), false)
+	c := c_callers(skip+1, &locbuf[0], int32(len(locbuf)), false)
 	printtrace(locbuf[:c], getg())
 }
 
@@ -77,7 +77,7 @@ func traceback() {
 func printtrace(locbuf []location, gp *g) {
 	for i := range locbuf {
 		if showframe(locbuf[i].function, gp) {
-			print(locbuf[i].function, "\n\t", locbuf[i].filename, ":", locbuf[i].lineno)
+			print(locbuf[i].function, "\n\t", locbuf[i].filename, ":", locbuf[i].lineno, "\n")
 		}
 	}
 }
Index: libgo/runtime/go-signal.c
===================================================================
--- libgo/runtime/go-signal.c	(revision 241163)
+++ libgo/runtime/go-signal.c	(working copy)
@@ -222,7 +222,7 @@ runtime_sighandler (int sig, Siginfo *in
 	  G *g;
 
 	  g = runtime_g ();
-	  runtime_traceback ();
+	  runtime_traceback (0);
 	  runtime_tracebackothers (g);
 
 	  /* The gc library calls runtime_dumpregs here, and provides
Index: libgo/runtime/heapdump.c
===================================================================
--- libgo/runtime/heapdump.c	(revision 241124)
+++ libgo/runtime/heapdump.c	(working copy)
@@ -545,6 +545,8 @@ dumpmemprof_callback(Bucket *b, uintptr
 	dumpint(frees);
 }
 
+static FuncVal dumpmemprof_callbackv = {(void(*)(void))dumpmemprof_callback};
+
 static void
 dumpmemprof(void)
 {
@@ -554,7 +556,7 @@ dumpmemprof(void)
 	SpecialProfile *spp;
 	byte *p;
 
-	runtime_iterate_memprof(dumpmemprof_callback);
+	runtime_iterate_memprof(&dumpmemprof_callbackv);
 
 	allspans = runtime_mheap.allspans;
 	for(spanidx=0; spanidx<runtime_mheap.nspan; spanidx++) {
Index: libgo/runtime/malloc.h
===================================================================
--- libgo/runtime/malloc.h	(revision 241197)
+++ libgo/runtime/malloc.h	(working copy)
@@ -465,7 +465,7 @@ void	runtime_MProf_Free(Bucket*, uintptr
   __asm__ (GOSYM_PREFIX "runtime.mProf_Free");
 void	runtime_MProf_GC(void)
   __asm__ (GOSYM_PREFIX "runtime.mProf_GC");
-void	runtime_iterate_memprof(void (*callback)(Bucket*, uintptr, Location*, uintptr, uintptr, uintptr))
+void	runtime_iterate_memprof(FuncVal* callback)
   __asm__ (GOSYM_PREFIX "runtime.iterate_memprof");
 int32	runtime_gcprocs(void);
 void	runtime_helpgc(int32 nproc);
@@ -535,7 +535,8 @@ void	runtime_gc_g_ptr(Eface*);
 void	runtime_gc_itab_ptr(Eface*);
 
 void	runtime_memorydump(void);
-int32	runtime_setgcpercent(int32);
+int32	runtime_setgcpercent(int32)
+  __asm__ (GOSYM_PREFIX "runtime.setgcpercent");
 
 // Value we use to mark dead pointers when GODEBUG=gcdead=1.
 #define PoisonGC ((uintptr)0xf969696969696969ULL)
Index: libgo/runtime/mgc0.c
===================================================================
--- libgo/runtime/mgc0.c	(revision 241197)
+++ libgo/runtime/mgc0.c	(working copy)
@@ -2392,14 +2392,16 @@ runtime_debug_readGCStats(Slice *pauses)
 	// pause_ns[(numgc-1)%nelem(pause_ns)], and then backward
 	// from there to go back farther in time. We deliver the times
 	// most recent first (in p[0]).
-	for(i=0; i<n; i++)
+	for(i=0; i<n; i++) {
 		p[i] = pmstats->pause_ns[(pmstats->numgc-1-i)%nelem(pmstats->pause_ns)];
+		p[n+i] = pmstats->pause_end[(pmstats->numgc-1-i)%nelem(pmstats->pause_ns)];
+	}
 
-	p[n] = pmstats->last_gc;
-	p[n+1] = pmstats->numgc;
-	p[n+2] = pmstats->pause_total_ns;
+	p[n+n] = pmstats->last_gc;
+	p[n+n+1] = pmstats->numgc;
+	p[n+n+2] = pmstats->pause_total_ns;
 	runtime_unlock(&runtime_mheap);
-	pauses->__count = n+3;
+	pauses->__count = n+n+3;
 }
 
 int32
Index: libgo/runtime/panic.c
===================================================================
--- libgo/runtime/panic.c	(revision 240956)
+++ libgo/runtime/panic.c	(working copy)
@@ -130,11 +130,11 @@ runtime_dopanic(int32 unused __attribute
 		if(g != runtime_m()->g0) {
 			runtime_printf("\n");
 			runtime_goroutineheader(g);
-			runtime_traceback();
+			runtime_traceback(0);
 			runtime_printcreatedby(g);
 		} else if(t >= 2 || runtime_m()->throwing > 0) {
 			runtime_printf("\nruntime stack:\n");
-			runtime_traceback();
+			runtime_traceback(0);
 		}
 		if(!didothers) {
 			didothers = true;
Index: libgo/runtime/proc.c
===================================================================
--- libgo/runtime/proc.c	(revision 241189)
+++ libgo/runtime/proc.c	(working copy)
@@ -3470,14 +3470,14 @@ runtime_testSchedLocalQueueSteal(void)
 	}
 }
 
-int32
-runtime_setmaxthreads(int32 in)
+intgo
+runtime_setmaxthreads(intgo in)
 {
-	int32 out;
+	intgo out;
 
 	runtime_lock(&runtime_sched);
-	out = runtime_sched.maxmcount;
-	runtime_sched.maxmcount = in;
+	out = (intgo)runtime_sched.maxmcount;
+	runtime_sched.maxmcount = (int32)in;
 	checkmcount();
 	runtime_unlock(&runtime_sched);
 	return out;
Index: libgo/runtime/rdebug.goc
===================================================================
--- libgo/runtime/rdebug.goc	(revision 240942)
+++ libgo/runtime/rdebug.goc	(working copy)
@@ -1,26 +0,0 @@
-// Copyright 2013 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_debug
-#include "runtime.h"
-#include "arch.h"
-#include "malloc.h"
-
-func setMaxStack(in int) (out int) {
-	out = runtime_maxstacksize;
-	runtime_maxstacksize = in;
-}
-
-func setGCPercent(in int) (out int) {
-	out = runtime_setgcpercent(in);
-}
-
-func setMaxThreads(in int) (out int) {
-	out = runtime_setmaxthreads(in);
-}
-
-func SetPanicOnFault(enabled bool) (old bool) {
-	old = runtime_g()->paniconfault;
-	runtime_g()->paniconfault = enabled;
-}
Index: libgo/runtime/runtime.c
===================================================================
--- libgo/runtime/runtime.c	(revision 241189)
+++ libgo/runtime/runtime.c	(working copy)
@@ -151,10 +151,6 @@ runtime_setdebug(struct debugVars* d) {
   runtime_debug = *d;
 }
 
-// Setting the max stack size doesn't really do anything for gccgo.
-
-uintptr runtime_maxstacksize = 1<<20; // enough until runtime.main sets it for real
-
 void memclrBytes(Slice)
      __asm__ (GOSYM_PREFIX "runtime.memclrBytes");
 
Index: libgo/runtime/runtime.h
===================================================================
--- libgo/runtime/runtime.h	(revision 241197)
+++ libgo/runtime/runtime.h	(working copy)
@@ -230,7 +230,7 @@ enum {
 };
 void	runtime_hashinit(void);
 
-void	runtime_traceback(void)
+void	runtime_traceback(int32)
   __asm__ (GOSYM_PREFIX "runtime.traceback");
 void	runtime_tracebackothers(G*)
   __asm__ (GOSYM_PREFIX "runtime.tracebackothers");
@@ -256,7 +256,6 @@ extern	int8*	runtime_goos;
 extern	int32	runtime_ncpu;
 extern 	void	(*runtime_sysargs)(int32, uint8**);
 extern	struct debugVars runtime_debug;
-extern	uintptr	runtime_maxstacksize;
 
 extern	bool	runtime_isstarted;
 extern	bool	runtime_isarchive;
@@ -411,7 +410,8 @@ void	runtime_crash(void);
 void	runtime_parsedebugvars(void)
   __asm__(GOSYM_PREFIX "runtime.parsedebugvars");
 void	_rt0_go(void);
-int32	runtime_setmaxthreads(int32);
+intgo	runtime_setmaxthreads(intgo)
+  __asm__ (GOSYM_PREFIX "runtime.setmaxthreads");
 G*	runtime_timejump(void);
 void	runtime_iterate_finq(void (*callback)(FuncVal*, void*, const FuncType*, const PtrType*));
 


More information about the Gcc-patches mailing list