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
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*));
