runtime: capture per-p trace state in a type

More tightening up of the tracer's interface.

Change-Id: I992141c7f30e5c2d5d77d1fcd6817d35bc6e5f6d
Reviewed-on: https://go-review.googlesource.com/c/go/+/494191
Auto-Submit: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Michael Pratt <mpratt@google.com>
Run-TryBot: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>

diff --git a/src/runtime/mgcsweep.go b/src/runtime/mgcsweep.go
index a9ee2a9db6610cf2bf03eaf33af5a44128391863..4b0d655a9d2008f2028f91c996a0e6e8c28da319 100644 (file)
--- a/src/runtime/mgcsweep.go
+++ b/src/runtime/mgcsweep.go
@@ -652,7 +652,7 @@ func (sl *sweepLocked) sweep(preserve bool) bool {
        s.freeindex = 0 // reset allocation index to start of span.
        s.freeIndexForScan = 0
        if traceEnabled() {
-               getg().m.p.ptr().traceReclaimed += uintptr(nfreed) * s.elemsize
+               getg().m.p.ptr().trace.reclaimed += uintptr(nfreed) * s.elemsize
        }
 
        // gcmarkBits becomes the allocBits.

diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 0350052a25caa75a178a87d48cece4e1ca157bb3..314ab194e787064a6001c5e04a112cbfa1f3d1f3 100644 (file)
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -674,15 +674,7 @@ type p struct {
                buf [128]*mspan
        }
 
-       tracebuf traceBufPtr
-
-       // traceSweep indicates the sweep events should be traced.
-       // This is used to defer the sweep start event until a span
-       // has actually been swept.
-       traceSweep bool
-       // traceSwept and traceReclaimed track the number of bytes
-       // swept and reclaimed by sweeping in the current sweep loop.
-       traceSwept, traceReclaimed uintptr
+       trace pTraceState
 
        palloc persistentAlloc // per-P to avoid mutex
 

diff --git a/src/runtime/trace.go b/src/runtime/trace.go
index 465e000c0e1ce27442d91e294fed0a981aea7b38..8a2ef17f2bb36c83e293371f1fc494112e49860f 100644 (file)
--- a/src/runtime/trace.go
+++ b/src/runtime/trace.go
@@ -174,6 +174,20 @@ type mTraceState struct {
        startingTrace bool // this M is in TraceStart, potentially before traceEnabled is true
 }
 
+// pTraceState is per-P state for the tracer.
+type pTraceState struct {
+       buf traceBufPtr
+
+       // inSweep indicates the sweep events should be traced.
+       // This is used to defer the sweep start event until a span
+       // has actually been swept.
+       inSweep bool
+
+       // swept and reclaimed track the number of bytes swept and reclaimed
+       // by sweeping in the current sweep loop (while inSweep was true).
+       swept, reclaimed uintptr
+}
+
 // traceLockInit initializes global trace locks.
 func traceLockInit() {
        lockInit(&trace.bufLock, lockRankTraceBuf)
@@ -379,10 +393,10 @@ func StopTrace() {
        // Loop over all allocated Ps because dead Ps may still have
        // trace buffers.
        for _, p := range allp[:cap(allp)] {
-               buf := p.tracebuf
+               buf := p.trace.buf
                if buf != 0 {
                        traceFullQueue(buf)
-                       p.tracebuf = 0
+                       p.trace.buf = 0
                }
        }
        if trace.buf != 0 {
@@ -429,7 +443,7 @@ func StopTrace() {
                // The lock protects us from races with StartTrace/StopTrace because they do stop-the-world.
                lock(&trace.lock)
                for _, p := range allp[:cap(allp)] {
-                       if p.tracebuf != 0 {
+                       if p.trace.buf != 0 {
                                throw("trace: non-empty trace buffer in proc")
                        }
                }
@@ -650,8 +664,8 @@ func traceReaderAvailable() *g {
 //
 //go:systemstack
 func traceProcFree(pp *p) {
-       buf := pp.tracebuf
-       pp.tracebuf = 0
+       buf := pp.trace.buf
+       pp.trace.buf = 0
        if buf == 0 {
                return
        }
@@ -980,7 +994,7 @@ func traceAcquireBuffer() (mp *m, pid int32, bufp *traceBufPtr) {
 
        mp = acquirem()
        if p := mp.p.ptr(); p != nil {
-               return mp, p.id, &p.tracebuf
+               return mp, p.id, &p.trace.buf
        }
        lock(&trace.bufLock)
        return mp, traceGlobProc, &trace.buf
@@ -1480,10 +1494,10 @@ func traceGCSweepStart() {
        // Delay the actual GCSweepStart event until the first span
        // sweep. If we don't sweep anything, don't emit any events.
        pp := getg().m.p.ptr()
-       if pp.traceSweep {
+       if pp.trace.inSweep {
                throw("double traceGCSweepStart")
        }
-       pp.traceSweep, pp.traceSwept, pp.traceReclaimed = true, 0, 0
+       pp.trace.inSweep, pp.trace.swept, pp.trace.reclaimed = true, 0, 0
 }
 
 // traceGCSweepSpan traces the sweep of a single page.
@@ -1492,23 +1506,23 @@ func traceGCSweepStart() {
 // pair; however, it will not emit any trace events in this case.
 func traceGCSweepSpan(bytesSwept uintptr) {
        pp := getg().m.p.ptr()
-       if pp.traceSweep {
-               if pp.traceSwept == 0 {
+       if pp.trace.inSweep {
+               if pp.trace.swept == 0 {
                        traceEvent(traceEvGCSweepStart, 1)
                }
-               pp.traceSwept += bytesSwept
+               pp.trace.swept += bytesSwept
        }
 }
 
 func traceGCSweepDone() {
        pp := getg().m.p.ptr()
-       if !pp.traceSweep {
+       if !pp.trace.inSweep {
                throw("missing traceGCSweepStart")
        }
-       if pp.traceSwept != 0 {
-               traceEvent(traceEvGCSweepDone, -1, uint64(pp.traceSwept), uint64(pp.traceReclaimed))
+       if pp.trace.swept != 0 {
+               traceEvent(traceEvGCSweepDone, -1, uint64(pp.trace.swept), uint64(pp.trace.reclaimed))
        }
-       pp.traceSweep = false
+       pp.trace.inSweep = false
 }
 
 func traceGCMarkAssistStart() {