From b5f34aa4abc1ae49b9f97355deb5ab097d0c68a9 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek <mknyszek@google.com>
Date: Wed, 29 Jan 2025 17:17:04 +0000
Subject: runtime: use internal/trace/tracev2 definitions

This change deduplicates trace wire format definitions between the
runtime and the trace parser by making the internal/trace/tracev2
package the source of truth.

Change-Id: Ia0721d3484a80417e40ac473ec32870bee73df09
Reviewed-on: https://go-review.googlesource.com/c/go/+/644221
Auto-Submit: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Michael Pratt <mpratt@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
---
 src/runtime/tracebuf.go | 36 +++++++++++++++++++++++++++++-------
 1 file changed, 29 insertions(+), 7 deletions(-)

(limited to 'src/runtime/tracebuf.go')

diff --git a/src/runtime/tracebuf.go b/src/runtime/tracebuf.go
index 0849a57809..63803a90f5 100644
--- a/src/runtime/tracebuf.go
+++ b/src/runtime/tracebuf.go
@@ -8,6 +8,7 @@ package runtime
 
 import (
 	"internal/runtime/sys"
+	"internal/trace/tracev2"
 	"unsafe"
 )
 
@@ -24,7 +25,7 @@ const traceBytesPerNumber = 10
 // we can change it if it's deemed too error-prone.
 type traceWriter struct {
 	traceLocker
-	exp traceExperiment
+	exp tracev2.Experiment
 	*traceBuf
 }
 
@@ -48,7 +49,7 @@ func (tl traceLocker) writer() traceWriter {
 			gp.throwsplit = true
 		}
 	}
-	return traceWriter{traceLocker: tl, traceBuf: tl.mp.trace.buf[tl.gen%2][traceNoExperiment]}
+	return traceWriter{traceLocker: tl, traceBuf: tl.mp.trace.buf[tl.gen%2][tracev2.NoExperiment]}
 }
 
 // unsafeTraceWriter produces a traceWriter that doesn't lock the trace.
@@ -70,7 +71,7 @@ func unsafeTraceWriter(gen uintptr, buf *traceBuf) traceWriter {
 // have any stack growth.
 //
 //go:nosplit
-func (w traceWriter) event(ev traceEv, args ...traceArg) traceWriter {
+func (w traceWriter) event(ev tracev2.EventType, args ...traceArg) traceWriter {
 	// N.B. Everything in this call must be nosplit to maintain
 	// the stack growth related invariants for writing events.
 
@@ -186,10 +187,10 @@ func (w traceWriter) refill() traceWriter {
 	}
 
 	// Write the buffer's header.
-	if w.exp == traceNoExperiment {
-		w.byte(byte(traceEvEventBatch))
+	if w.exp == tracev2.NoExperiment {
+		w.byte(byte(tracev2.EvEventBatch))
 	} else {
-		w.byte(byte(traceEvExperimentalBatch))
+		w.byte(byte(tracev2.EvExperimentalBatch))
 		w.byte(byte(w.exp))
 	}
 	w.varint(uint64(w.gen))
@@ -199,6 +200,27 @@ func (w traceWriter) refill() traceWriter {
 	return w
 }
 
+// expWriter returns a traceWriter that writes into the current M's stream for
+// the given experiment.
+func (tl traceLocker) expWriter(exp tracev2.Experiment) traceWriter {
+	return traceWriter{traceLocker: tl, traceBuf: tl.mp.trace.buf[tl.gen%2][exp], exp: exp}
+}
+
+// unsafeTraceExpWriter produces a traceWriter for experimental trace batches
+// that doesn't lock the trace. Data written to experimental batches need not
+// conform to the standard trace format.
+//
+// It should only be used in contexts where either:
+// - Another traceLocker is held.
+// - trace.gen is prevented from advancing.
+//
+// This does not have the same stack growth restrictions as traceLocker.writer.
+//
+// buf may be nil.
+func unsafeTraceExpWriter(gen uintptr, buf *traceBuf, exp tracev2.Experiment) traceWriter {
+	return traceWriter{traceLocker: traceLocker{gen: gen}, traceBuf: buf, exp: exp}
+}
+
 // traceBufQueue is a FIFO of traceBufs.
 type traceBufQueue struct {
 	head, tail *traceBuf
@@ -247,7 +269,7 @@ type traceBufHeader struct {
 type traceBuf struct {
 	_ sys.NotInHeap
 	traceBufHeader
-	arr [64<<10 - unsafe.Sizeof(traceBufHeader{})]byte // underlying buffer for traceBufHeader.buf
+	arr [tracev2.MaxBatchSize - unsafe.Sizeof(traceBufHeader{})]byte // underlying buffer for traceBufHeader.buf
 }
 
 // byte appends v to buf.
-- 
cgit v1.3-5-g45d5