feat: add GoID to the output of runtime.GoroutineProfile()

vaind · vaind · commit 599d78efe8c3 · 2024-05-29T10:05:46.000+02:00
diff --git a/src/internal/profilerecord/profilerecord.go b/src/internal/profilerecord/profilerecord.go
@@ -10,6 +10,7 @@ package profilerecord
 
 type StackRecord struct {
 	Stack []uintptr
+	GoID  uint64
 }
 
 type MemProfileRecord struct {
diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go
@@ -1009,6 +1009,7 @@ func mutexevent(cycles int64, skip int) {
 // A StackRecord describes a single execution stack.
 type StackRecord struct {
 	Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry
+	goid   uint64      // Goroutine ID for the first record (or 0 if undefined by the struct creator).
 }
 
 // Stack returns the stack trace associated with the record,
@@ -1022,6 +1023,11 @@ func (r *StackRecord) Stack() []uintptr {
 	return r.Stack0[0:]
 }
 
+// GoID returns an identifier for the Goroutine this stack was captured for, or zero if undefined.
+func (r *StackRecord) GoID() uint64 {
+	return r.goid
+}
+
 // MemProfileRate controls the fraction of memory allocations
 // that are recorded and reported in the memory profile.
 // The profiler aims to sample an average of
@@ -1707,6 +1713,7 @@ func GoroutineProfile(p []StackRecord) (n int, ok bool) {
 	}
 	for i, mr := range records[0:n] {
 		copy(p[i].Stack0[:], mr.Stack)
+		p[i].goid = mr.GoID
 	}
 	return
 }
@@ -1735,6 +1742,7 @@ func saveg(pc, sp uintptr, gp *g, r *profilerecord.StackRecord, pcbuf []uintptr)
 	n := tracebackPCs(&u, 0, pcbuf)
 	r.Stack = make([]uintptr, n)
 	copy(r.Stack, pcbuf)
+	r.GoID = gp.goid
 }
 
 // Stack formats a stack trace of the calling goroutine into buf
diff --git a/src/runtime/runtime_test.go b/src/runtime/runtime_test.go
@@ -344,17 +344,19 @@ func TestAppendSliceGrowth(t *testing.T) {
 	}
 }
 
-func TestGoroutineProfileTrivial(t *testing.T) {
+func TestGoroutineProfile(t *testing.T) {
 	// Calling GoroutineProfile twice in a row should find the same number of goroutines,
 	// but it's possible there are goroutines just about to exit, so we might end up
 	// with fewer in the second call. Try a few times; it should converge once those
 	// zombies are gone.
+	var records []StackRecord
 	for i := 0; ; i++ {
 		n1, ok := GoroutineProfile(nil) // should fail, there's at least 1 goroutine
 		if n1 < 1 || ok {
 			t.Fatalf("GoroutineProfile(nil) = %d, %v, want >0, false", n1, ok)
 		}
-		n2, ok := GoroutineProfile(make([]StackRecord, n1))
+		records = make([]StackRecord, n1)
+		n2, ok := GoroutineProfile(records)
 		if n2 == n1 && ok {
 			break
 		}
@@ -363,6 +365,17 @@ func TestGoroutineProfileTrivial(t *testing.T) {
 			t.Fatalf("GoroutineProfile not converging")
 		}
 	}
+	if len(records) < 1 {
+		t.Fatalf("GoroutineProfile hasn't collected any records")
+	}
+	for _, record := range records {
+		if len(record.Stack()) < 1 {
+			t.Fatalf("GoroutineProfile record is missing a stack trace")
+		}
+		if record.GoID() < 1 {
+			t.Fatalf("GoroutineProfile record is missing a GoID")
+		}
+	}
 }
 
 func BenchmarkGoroutineProfile(b *testing.B) {

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ package profilerecord`
`10`	`10`
`11`	`11`	`type StackRecord struct {`
`12`	`12`	`Stack []uintptr`
	`13`	`+ GoID uint64`
`13`	`14`	`}`
`14`	`15`
`15`	`16`	`type MemProfileRecord struct {`
Original file line number	Diff line number	Diff line change
`@@ -1009,6 +1009,7 @@ func mutexevent(cycles int64, skip int) {`
`1009`	`1009`	`// A StackRecord describes a single execution stack.`
`1010`	`1010`	`type StackRecord struct {`
`1011`	`1011`	`Stack0 [32]uintptr // stack trace for this record; ends at first 0 entry`
	`1012`	`+ goid uint64 // Goroutine ID for the first record (or 0 if undefined by the struct creator).`
`1012`	`1013`	`}`
`1013`	`1014`
`1014`	`1015`	`// Stack returns the stack trace associated with the record,`
`@@ -1022,6 +1023,11 @@ func (r *StackRecord) Stack() []uintptr {`
`1022`	`1023`	`return r.Stack0[0:]`
`1023`	`1024`	`}`
`1024`	`1025`
	`1026`	`+// GoID returns an identifier for the Goroutine this stack was captured for, or zero if undefined.`
	`1027`	`+func (r *StackRecord) GoID() uint64 {`
	`1028`	`+ return r.goid`
	`1029`	`+}`
	`1030`	`+`
`1025`	`1031`	`// MemProfileRate controls the fraction of memory allocations`
`1026`	`1032`	`// that are recorded and reported in the memory profile.`
`1027`	`1033`	`// The profiler aims to sample an average of`
`@@ -1707,6 +1713,7 @@ func GoroutineProfile(p []StackRecord) (n int, ok bool) {`
`1707`	`1713`	`}`
`1708`	`1714`	`for i, mr := range records[0:n] {`
`1709`	`1715`	`copy(p[i].Stack0[:], mr.Stack)`
	`1716`	`+ p[i].goid = mr.GoID`
`1710`	`1717`	`}`
`1711`	`1718`	`return`
`1712`	`1719`	`}`
`@@ -1735,6 +1742,7 @@ func saveg(pc, sp uintptr, gp g, r profilerecord.StackRecord, pcbuf []uintptr)`
`1735`	`1742`	`n := tracebackPCs(&u, 0, pcbuf)`
`1736`	`1743`	`r.Stack = make([]uintptr, n)`
`1737`	`1744`	`copy(r.Stack, pcbuf)`
	`1745`	`+ r.GoID = gp.goid`
`1738`	`1746`	`}`
`1739`	`1747`
`1740`	`1748`	`// Stack formats a stack trace of the calling goroutine into buf`
Original file line number	Diff line number	Diff line change
`@@ -344,17 +344,19 @@ func TestAppendSliceGrowth(t *testing.T) {`
`344`	`344`	`}`
`345`	`345`	`}`
`346`	`346`
`347`		`-func TestGoroutineProfileTrivial(t *testing.T) {`
	`347`	`+func TestGoroutineProfile(t *testing.T) {`
`348`	`348`	`// Calling GoroutineProfile twice in a row should find the same number of goroutines,`
`349`	`349`	`// but it's possible there are goroutines just about to exit, so we might end up`
`350`	`350`	`// with fewer in the second call. Try a few times; it should converge once those`
`351`	`351`	`// zombies are gone.`
	`352`	`+ var records []StackRecord`
`352`	`353`	`for i := 0; ; i++ {`
`353`	`354`	`n1, ok := GoroutineProfile(nil) // should fail, there's at least 1 goroutine`
`354`	`355`	`if n1 < 1 \|\| ok {`
`355`	`356`	`t.Fatalf("GoroutineProfile(nil) = %d, %v, want >0, false", n1, ok)`
`356`	`357`	`}`
`357`		`- n2, ok := GoroutineProfile(make([]StackRecord, n1))`
	`358`	`+ records = make([]StackRecord, n1)`
	`359`	`+ n2, ok := GoroutineProfile(records)`
`358`	`360`	`if n2 == n1 && ok {`
`359`	`361`	`break`
`360`	`362`	`}`
`@@ -363,6 +365,17 @@ func TestGoroutineProfileTrivial(t *testing.T) {`
`363`	`365`	`t.Fatalf("GoroutineProfile not converging")`
`364`	`366`	`}`
`365`	`367`	`}`
	`368`	`+ if len(records) < 1 {`
	`369`	`+ t.Fatalf("GoroutineProfile hasn't collected any records")`
	`370`	`+ }`
	`371`	`+ for _, record := range records {`
	`372`	`+ if len(record.Stack()) < 1 {`
	`373`	`+ t.Fatalf("GoroutineProfile record is missing a stack trace")`
	`374`	`+ }`
	`375`	`+ if record.GoID() < 1 {`
	`376`	`+ t.Fatalf("GoroutineProfile record is missing a GoID")`
	`377`	`+ }`
	`378`	`+ }`
`366`	`379`	`}`
`367`	`380`
`368`	`381`	`func BenchmarkGoroutineProfile(b *testing.B) {`