Renamed deadlockgc to golfgc and deadlocks to goroutine leaks to avoid confusion with global deadlock.

Author: VladSaiocUber

src/internal/goexperiment/exp_deadlockgc_off.go

@@ -134,6 +134,6 @@ type Flags struct {
 	// platforms.
 	RandomizedHeapBase64 bool
 
-	// DeadlockGC enables the Deadlock GC implementation.
-	DeadlockGC bool
+	// GolfGC enables the Deadlock GC implementation.
+	GolfGC bool
 }

src/internal/goexperiment/exp_deadlockgc_on.go

@@ -373,32 +373,35 @@ type workType struct {
 
 	// Number of roots of various root types. Set by gcPrepareMarkRoots.
 	//
-	// During normal GC cycle, nStackRoots == nLiveStackRoots == len(stackRoots)
-	// during deadlock detection GC, nLiveStackRoots is the number of stackRoots
+	// During normal GC cycle, nStackRoots == nLiveStackRoots == len(stackRoots);
+	// during goroutine leak detection, nLiveStackRoots is the number of stackRoots
 	// to examine, and nStackRoots == len(stackRoots), which include goroutines that are
 	// unmarked / not runnable
 	nDataRoots, nBSSRoots, nSpanRoots, nStackRoots, nLiveStackRoots int
 
-	// The GC has performed deadlock detection during this GC cycle.
-	detectedDeadlocks bool
-
-	// Is set to true by DetectDeadlocks(), instructing the next GC cycle to perform deadlock detection.
-	pendingDeadlockDetection bool
-
-	// When set, the GC is running in deadlock detection mode.
-	// This can be triggered with a runtime flag.
-	deadlockDetectionMode bool
+	// The following fields monitor the GC phase of the current cycle during
+	// goroutine leak detection.
+	//
+	// - pendingGoleakDetection: The GC has been instructed to perform goroutine leak
+	// 	 detection during the next GC cycle; it is set by DetectGoroutineLeaks()
+	// 	 and unset during gcStart().
+	// - detectingGoleaks: The GC is running in goroutine leak detection mode; it is set
+	// 	 during gcStart() and unset during gcMarkTermination().
+	// - detectedGoleaks: The GC has performed goroutine leak detection during the current
+	//   GC cycle; it is set during gcMarkDone(), right after goroutine leak detection has concluded,
+	//   and unset during gcStart().
+	pendingGoleakDetection, detectingGoleaks, detectedGoleaks bool
 
 	// Base indexes of each root type. Set by gcPrepareMarkRoots.
 	baseData, baseBSS, baseSpans, baseStacks, baseEnd uint32
 
 	// stackRoots is a snapshot of all of the Gs that existed before the
-	// beginning of concurrent marking.  During deadlock detection GC, stackRoots
+	// beginning of concurrent marking.  During goroutine leak detection, stackRoots
 	// is partitioned into two sets; to the left of nLiveStackRoots are stackRoots
 	// of running / runnable goroutines and to the right of nLiveStackRoots are
 	// stackRoots of unmarked / not runnable goroutines
 	// gcDiscoverMoreStackRoots modifies the stackRoots array to redo the partition
-	// after each marking phase
+	// after each marking phase iteration.
 	stackRoots []*g
 
 	// Each type of GC state transition is protected by a lock.
@@ -565,25 +568,25 @@ func GC() {
 	releasem(mp)
 }
 
-// DetectDeadlocks instructs the Go garbage collector to attempt
-// partial deadlock detection.
+// FindGoleaks instructs the Go garbage collector to attempt
+// goroutine leak detection during the next GC cycle.
 //
-// Only operates if deadlockgc is enabled in GOEXPERIMENT.
+// Only operates if golfgc is enabled in GOEXPERIMENT.
 // Otherwise, it just runs runtime.GC().
-func DetectDeadlocks() {
-	if !goexperiment.DeadlockGC {
+func FindGoLeaks() {
+	if !goexperiment.GolfGC {
 		GC()
 		return
 	}
 
 	// This write should be thread-safe, as the overwritten value is true.
-	// pendingDeadlockDetection is only set to false under STW at the start
+	// pendingGoleakDetection is only set to false under STW at the start
 	// of the GC cycle that picks it up.
-	work.pendingDeadlockDetection = true
+	work.pendingGoleakDetection = true
 
 	// This read should be thread-safe for the same reason as the write above above.
 	// At most, we trigger the GC an additional time.
-	for work.pendingDeadlockDetection {
+	for work.pendingGoleakDetection {
 		GC()
 	}
 }
@@ -733,8 +736,8 @@ func gcStart(trigger gcTrigger) {
 		mode = gcForceMode
 	} else if debug.gcstoptheworld == 2 {
 		mode = gcForceBlockMode
-	} else if goexperiment.DeadlockGC {
-		if work.pendingDeadlockDetection {
+	} else if goexperiment.GolfGC {
+		if work.pendingGoleakDetection {
 			// Fully stop the world if running deadlock detection.
 			mode = gcForceBlockMode
 		}
@@ -800,7 +803,7 @@ func gcStart(trigger gcTrigger) {
 	clearpools()
 
 	work.cycles.Add(1)
-	work.detectedDeadlocks = false
+	work.detectedGoleaks = false
 
 	// Assists and workers can start the moment we start
 	// the world.
@@ -832,11 +835,11 @@ func gcStart(trigger gcTrigger) {
 	// possible.
 	setGCPhase(_GCmark)
 
-	if goexperiment.DeadlockGC {
-		if work.pendingDeadlockDetection {
+	if goexperiment.GolfGC {
+		if work.pendingGoleakDetection {
 			// Write is thread-safe because the world is stopped
-			work.deadlockDetectionMode = true
-			work.pendingDeadlockDetection = false
+			work.detectingGoleaks = true
+			work.pendingGoleakDetection = false
 		}
 	}
 
@@ -940,8 +943,8 @@ func gcMarkDone() {
 	// Ensure only one thread is running the ragged barrier at a
 	// time.
 	semacquire(&work.markDoneSema)
-	if goexperiment.DeadlockGC {
-		if work.deadlockDetectionMode {
+	if goexperiment.GolfGC {
+		if work.detectingGoleaks {
 			gcDiscoverMoreStackRoots()
 		}
 	}
@@ -1050,11 +1053,13 @@ top:
 		})
 		semrelease(&worldsema)
 		goto top
-	} else if goexperiment.DeadlockGC {
-		// Otherwise, do a deadlock detection round.
-		// Only do one deadlock detection round per GC cycle.
-		if work.deadlockDetectionMode && !work.detectedDeadlocks {
-			work.detectedDeadlocks = detectDeadlocks()
+	} else if goexperiment.GolfGC {
+		// If we are detecting goroutine leaks, do so now.
+		if work.detectingGoleaks && !work.detectedGoleaks {
+			// Detect goroutine leaks. If the returned value is true, then
+			// detection was performed during this cycle. Otherwise, more mark work is needed,
+			// or live goroutines were found.
+			work.detectedGoleaks = findGoleaks()
 
 			getg().m.preemptoff = ""
 			systemstack(func() {
@@ -1243,12 +1248,12 @@ func gcDiscoverMoreStackRoots() {
 	}
 }
 
-// detectDeadlocks scans the remaining stackRoots and marks any which are
+// findGoleaks scans the remaining stackRoots and marks any which are
 // blocked over exclusively unreachable concurrency primitives as leaked (deadlocked).
-// Returns true if goroutine leak was performed (or unnecessary).
-// Returns false if the GC cycle has not yet reached a fix point for reachable goroutines.
-func detectDeadlocks() bool {
-	// Report deadlocks and mark them unreachable, and resume marking
+// Returns true if the goroutine leak check was performed (or unnecessary).
+// Returns false if the GC cycle has not yet computed all (maybe-)live goroutines.
+func findGoleaks() bool {
+	// Report goroutine leaks and mark them unreachable, and resume marking
 	// we still need to mark these unreachable *g structs as they
 	// get reused, but their stack won't get scanned
 	if work.nLiveStackRoots == work.nStackRoots {
@@ -1281,10 +1286,10 @@ func detectDeadlocks() bool {
 		return false
 	}
 
-	// For the remaining goroutines, mark them as unreachable and deadlocking.
+	// For the remaining goroutines, mark them as unreachable and leaked.
 	for i := work.nLiveStackRoots; i < work.nStackRoots; i++ {
 		gp := work.stackRoots[i].unmask()
-		casgstatus(gp, _Gwaiting, _Gdeadlocked)
+		casgstatus(gp, _Gwaiting, _Gleaked)
 		fn := findfunc(gp.startpc)
 		if fn.valid() {
 			print("goroutine leak! goroutine ", gp.goid, ": ", funcname(fn), " Stack size: ", gp.stack.hi-gp.stack.lo, " bytes\n")
@@ -1454,11 +1459,11 @@ func gcMarkTermination(stw worldStop) {
 	}
 
 	systemstack(func() {
-		if goexperiment.DeadlockGC {
-			// Pull the GC out of deadlock detection mode.
+		if goexperiment.GolfGC {
+			// Pull the GC out of goroutine leak detection mode.
 			// Write is thread-safe because the world is stopped, and only one
 			// GC cycle can run at a time.
-			work.deadlockDetectionMode = false
+			work.detectingGoleaks = false
 		}
 
 		// The memstats updated above must be updated with the world
@@ -1888,7 +1893,7 @@ func gcMarkWorkAvailable(p *p) bool {
 	if !work.full.empty() || !work.spanq.empty() {
 		return true // global work available
 	}
-	if !work.deadlockDetectionMode {
+	if !work.detectingGoleaks {
 		return work.markrootNext < work.markrootJobs
 	}
 	rootNext := atomic.Load(&work.markrootNext)

src/internal/goexperiment/exp_golfgc_off.go

@@ -60,7 +60,7 @@ const (
 //
 //go:nosplit
 func gcMask(p unsafe.Pointer) unsafe.Pointer {
-	if goexperiment.DeadlockGC {
+	if goexperiment.GolfGC {
 		return unsafe.Pointer(uintptr(p) | gcBitMask)
 	}
 	return p
@@ -70,15 +70,15 @@ func gcMask(p unsafe.Pointer) unsafe.Pointer {
 //
 //go:nosplit
 func gcUnmask(p unsafe.Pointer) unsafe.Pointer {
-	if goexperiment.DeadlockGC {
+	if goexperiment.GolfGC {
 		return unsafe.Pointer(uintptr(p) & gcUndoBitMask)
 	}
 	return p
 }
 
-// internalBlocked returns true if the goroutine is blocked due to a
-// non-deadlocking waitReason, e.g. waiting for the netpoller or garbage collector.
-// Such goroutines should never be considered for deadlock detection.
+// internalBlocked returns true if the goroutine is blocked due to an
+// internal (non-leaking) waitReason, e.g. waiting for the netpoller or garbage collector.
+// Such goroutines are never leak detection candidates according to the GC.
 //
 //go:nosplit
 func (gp *g) internalBlocked() bool {
@@ -170,8 +170,8 @@ func gcPrepareMarkRoots() {
 	// ignore them because they begin life without any roots, so
 	// there's nothing to scan, and any roots they create during
 	// the concurrent phase will be caught by the write barrier.
-	if goexperiment.DeadlockGC {
-		if work.deadlockDetectionMode {
+	if goexperiment.GolfGC {
+		if work.detectingGoleaks {
 			work.stackRoots, work.nLiveStackRoots = allGsSnapshotSortedForGC()
 		} else {
 			// regular GC --- scan every go routine
@@ -950,7 +950,7 @@ func scanstack(gp *g, gcw *gcWork) int64 {
 	case _Grunning:
 		print("runtime: gp=", gp, ", goid=", gp.goid, ", gp->atomicstatus=", readgstatus(gp), "\n")
 		throw("scanstack: goroutine not stopped")
-	case _Grunnable, _Gsyscall, _Gwaiting, _Gdeadlocked:
+	case _Grunnable, _Gsyscall, _Gwaiting, _Gleaked:
 		// ok
 	}
 
@@ -1307,8 +1307,6 @@ func gcDrain(gcw *gcWork, flags gcDrainFlags) {
 	if rootNext < rootJobs {
 		// Stop if we're preemptible, if someone wants to STW, or if
 		// someone is calling forEachP.
-		//
-		// Continue unconditionally if we're draining partial deadlocks.
 		for !(gp.preempt && (preemptible || sched.gcwaiting.Load() || pp.runSafePointFn != 0)) {
 			job, success := gcUpdateMarkrootNext()
 			if !success {
@@ -1623,9 +1621,9 @@ func scanobject(b uintptr, gcw *gcWork) {
 
 		// At this point we have extracted the next potential pointer.
 		// Quickly filter out nil and pointers back to the current object.
-		// The GC will skip masked addresses if DeadlockGC is enabled.
+		// The GC will skip masked addresses if GolfGC is enabled.
 		if obj != 0 && obj-b >= n &&
-			(!goexperiment.DeadlockGC || obj <= gcUndoBitMask) {
+			(!goexperiment.GolfGC || obj <= gcUndoBitMask) {
 			// Test if obj points into the Go heap and, if so,
 			// mark the object.
 			//

src/internal/goexperiment/exp_golfgc_on.go

@@ -160,7 +160,7 @@ func suspendG(gp *g) suspendGState {
 			s = _Gwaiting
 			fallthrough
 
-		case _Grunnable, _Gsyscall, _Gwaiting, _Gdeadlocked:
+		case _Grunnable, _Gsyscall, _Gwaiting, _Gleaked:
 			// Claim goroutine by setting scan bit.
 			// This may race with execution or readying of gp.
 			// The scan bit keeps it from transition state.
@@ -269,7 +269,7 @@ func resumeG(state suspendGState) {
 
 	case _Grunnable | _Gscan,
 		_Gwaiting | _Gscan,
-		_Gdeadlocked | _Gscan,
+		_Gleaked | _Gscan,
 		_Gsyscall | _Gscan:
 		casfrom_Gscanstatus(gp, s, s&^_Gscan)
 	}

src/internal/goexperiment/flags.go

@@ -709,7 +709,7 @@ func allGsSnapshot() []*g {
 	// monotonically and existing entries never change, so we can
 	// simply return a copy of the slice header. For added safety,
 	// we trim everything past len because that can still change.
-	if goexperiment.DeadlockGC {
+	if goexperiment.GolfGC {
 		for i, gp := range allgs {
 			allgs[i] = gp.unmask()
 		}

src/runtime/mgc.go

@@ -87,8 +87,8 @@ const (
 	// ready()ing this G.
 	_Gpreempted // 9
 
-	// _Gdeadlocked represents a deadlocked goroutine caught by the GC.
-	_Gdeadlocked // 10
+	// _Gleaked represents a deadlocked goroutine caught by the GC.
+	_Gleaked // 10
 
 	// _Gscan combined with one of the above states other than
 	// _Grunning indicates that GC is scanning the stack. The
@@ -108,7 +108,7 @@ const (
 	_Gscanwaiting   = _Gscan + _Gwaiting   // 0x1004
 	_Gscanpreempted = _Gscan + _Gpreempted // 0x1009
 
-	_Gscandeadlocked = _Gscan + _Gdeadlocked // 0x100a
+	_Gscandeadlocked = _Gscan + _Gleaked // 0x100a
 )
 
 const (