Removed FindGoLeaks API, addressed nits, and cleaned comments.

Author: VladSaiocUber

src/runtime/mgc.go

@@ -569,24 +569,6 @@ func GC() {
 	releasem(mp)
 }
 
-// FindGoleaks instructs the Go garbage collector to attempt
-// goroutine leak detection during the next GC cycle.
-//
-// Only operates if goroutineleakfindergc is enabled in GOEXPERIMENT.
-// Otherwise, it just runs runtime.GC().
-func FindGoLeaks() {
-	if !goexperiment.GoroutineLeakFinderGC {
-		GC()
-		return
-	}
-
-	work.goroutineLeakFinder.pending.Store(true)
-
-	for work.goroutineLeakFinder.pending.Load() {
-		GC()
-	}
-}
-
 // gcWaitOnMark blocks until GC finishes the Nth mark phase. If GC has
 // already completed this mark phase, it returns immediately.
 func gcWaitOnMark(n uint32) {
@@ -1095,13 +1077,11 @@ top:
 	gcMarkTermination(stw)
 }
 
-// checkIfMaybeRunnable checks whether a goroutine may still be semantically runnable.
+// isMaybeRunnable checks whether a goroutine may still be semantically runnable.
 // For goroutines which are semantically runnable, this will eventually return true
 // as the GC marking phase progresses. It returns false for leaked goroutines, or for
 // goroutines which are not yet computed as possibly runnable by the GC.
-func (gp *g) checkIfMaybeRunnable() bool {
-	// Unmask the goroutine address to ensure we are not
-	// dereferencing a masked address.
+func (gp *g) isMaybeRunnable() bool {
 	switch gp.waitreason {
 	case waitReasonSelectNoCases,
 		waitReasonChanSendNilChan,
@@ -1128,7 +1108,6 @@ func (gp *g) checkIfMaybeRunnable() bool {
 		// If waiting on mutexes, wait groups, or condition variables,
 		// check if the synchronization primitive attached to the sudog is marked.
 		if gp.waiting != nil {
-			// Unmask the sema address and check if it's marked.
 			return isMarkedOrNotInHeap(gp.waiting.elem.get())
 		}
 	}
@@ -1148,12 +1127,12 @@ func findMaybeRunnableGoroutines() (moreWork bool) {
 	var vIndex, ivIndex int = work.nMaybeRunnableStackRoots, work.nStackRoots
 	// Reorder goroutine list
 	for vIndex < ivIndex {
-		if work.stackRoots[vIndex].checkIfMaybeRunnable() {
+		if work.stackRoots[vIndex].isMaybeRunnable() {
 			vIndex = vIndex + 1
 			continue
 		}
 		for ivIndex = ivIndex - 1; ivIndex != vIndex; ivIndex = ivIndex - 1 {
-			if gp := work.stackRoots[ivIndex]; gp.checkIfMaybeRunnable() {
+			if gp := work.stackRoots[ivIndex]; gp.isMaybeRunnable() {
 				work.stackRoots[ivIndex] = work.stackRoots[vIndex]
 				work.stackRoots[vIndex] = gp
 				vIndex = vIndex + 1
@@ -1186,8 +1165,6 @@ func gcUntrackSyncObjects() {
 
 // gcRestoreSyncObjects restores the elem and c fields of all sudogs to their original values.
 // Should be invoked after the goroutine leak detection phase.
-//
-//go:nosplit
 func gcRestoreSyncObjects() {
 	assertWorldStopped()
 

src/runtime/mgcmark.go

@@ -63,13 +63,12 @@ func (gp *g) internalBlocked() bool {
 	return reason < waitReasonChanReceiveNilChan || waitReasonSyncWaitGroupWait < reason
 }
 
+// allGsSnapshotSortedForGC takes a snapshot of allgs and returns a sorted
+// array of Gs. The array is sorted by the G's status, with running Gs
+// first, followed by blocked Gs. The returned index indicates the cutoff
+// between runnable and blocked Gs.
+//
 // The world must be stopped or allglock must be held.
-// go through the snapshot of allgs, putting them into an arrays,
-// separated by index, where [0:blockedIndex] contains only running Gs
-// allGs[blockedIndex:] contain only blocking Gs
-// To avoid GC from marking and scanning the blocked Gs by scanning
-// the returned array (which is heap allocated), we mask the highest
-// bit of the pointers to Gs with gcBitMask.
 func allGsSnapshotSortedForGC() ([]*g, int) {
 	assertWorldStoppedOrLockHeld(&allglock)
 
@@ -1195,7 +1194,11 @@ func gcDrainMarkWorkerFractional(gcw *gcWork) {
 	gcDrain(gcw, gcDrainFractional|gcDrainUntilPreempt|gcDrainFlushBgCredit)
 }
 
-func gcUpdateMarkrootNext() (uint32, bool) {
+// gcNextMarkRoot safely increments work.markrootNext and returns the
+// index of the next root job. The returned boolean is true if the root job
+// is valid, and false if there are no more root jobs to be claimed,
+// i.e. work.markrootNext >= work.markrootJobs.
+func gcNextMarkRoot() (uint32, bool) {
 	var success bool
 	next, jobs := work.markrootNext.Load(), work.markrootJobs.Load()
 
@@ -1281,8 +1284,8 @@ func gcDrain(gcw *gcWork, flags gcDrainFlags) {
 		// Stop if we're preemptible, if someone wants to STW, or if
 		// someone is calling forEachP.
 		for !(gp.preempt && (preemptible || sched.gcwaiting.Load() || pp.runSafePointFn != 0)) {
-			job, success := gcUpdateMarkrootNext()
-			if !success {
+			job, ok := gcNextMarkRoot()
+			if !ok {
 				break
 			}
 			markroot(gcw, job, flushBgCredit)
@@ -1429,8 +1432,8 @@ func gcDrainN(gcw *gcWork, scanWork int64) int64 {
 					if b = gcw.tryGetObj(); b == 0 {
 						// Try to do a root job.
 						if work.markrootNext.Load() < work.markrootJobs.Load() {
-							job, success := gcUpdateMarkrootNext()
-							if success {
+							job, ok := gcNextMarkRoot()
+							if ok {
 								workFlushed += markroot(gcw, job, false)
 								continue
 							}