-880cb0a45590d992880fc6aabc7484e54c817eeb
+314ba28067383516c213ba84c931f93325a48c39
The first line of this file holds the git revision number of the last
merge done from the gofrontend repository.
lfstack.c \
malloc.c \
netpoll.c \
- rdebug.c \
reflect.c \
runtime1.c \
sigqueue.c \
os/user/check \
path/filepath/check \
regexp/syntax/check \
+ runtime/debug/check \
runtime/pprof/check \
runtime/internal/atomic/check \
runtime/internal/sys/check \
$(am__objects_2) panic.lo parfor.lo print.lo proc.lo \
runtime.lo signal_unix.lo thread.lo $(am__objects_3) yield.lo \
$(am__objects_4) go-iface.lo lfstack.lo malloc.lo netpoll.lo \
- rdebug.lo reflect.lo runtime1.lo sigqueue.lo $(am__objects_5)
+ reflect.lo runtime1.lo sigqueue.lo $(am__objects_5)
am_libgo_llgo_la_OBJECTS = $(am__objects_6)
libgo_llgo_la_OBJECTS = $(am_libgo_llgo_la_OBJECTS)
libgo_llgo_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
lfstack.c \
malloc.c \
netpoll.c \
- rdebug.c \
reflect.c \
runtime1.c \
sigqueue.c \
os/user/check \
path/filepath/check \
regexp/syntax/check \
+ runtime/debug/check \
runtime/pprof/check \
runtime/internal/atomic/check \
runtime/internal/sys/check \
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/parfor.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/proc.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rdebug.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/reflect.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rtems-task-variable-add.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/runtime.Plo@am__quote@
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.
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 {
// 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
// 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.
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)
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) {
--- /dev/null
+// 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
gp.m.traceback = 1
gp.writebuf = buf[0:0:len(buf)]
goroutineheader(gp)
- traceback()
+ traceback(1)
if all {
tracebackothers(gp)
}
}
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.
gp.m.traceback = 2
print("tracefree(", p, ", ", hex(size), ")\n")
goroutineheader(gp)
- traceback()
+ traceback(1)
print("\n")
gp.m.traceback = 0
unlock(&tracelock)
--- /dev/null
+// 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
+}
// 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)
+}
// 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())
}
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")
}
}
}
G *g;
g = runtime_g ();
- runtime_traceback ();
+ runtime_traceback (0);
runtime_tracebackothers (g);
/* The gc library calls runtime_dumpregs here, and provides
dumpint(frees);
}
+static FuncVal dumpmemprof_callbackv = {(void(*)(void))dumpmemprof_callback};
+
static void
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++) {
__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);
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)
// 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
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;
}
}
-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;
+++ /dev/null
-// 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;
-}
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");
};
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");
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;
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*));
projects / platform / upstream / gcc.git / commitdiff