// only heap object memory. Intuitively, the way we convert from one to the other is to
	// subtract everything from memoryLimit that both contributes to the memory limit (so,
	// ignore scavenged memory) and doesn't contain heap objects. This isn't quite what
	// lines up with reality, but it's a good starting point.
	//
	// In practice this computation looks like the following:
	//

		// close to done sweeping.

		// Move the scavenge gen forward (signaling
		// that there's new work to do) and wake the scavenger.
		//
		// The scavenger is signaled by the last sweeper because once
		// sweeping is done, we will definitely have useful work for
		// the scavenger to do, since the scavenger only runs over the
		// heap once per GC cycle. This update is not done during sweep

const ranks = `
# Sysmon
NONE
< sysmon
< scavenge, forcegc;

# Defer
NONE < defer;

# GC
NONE <
  sweepWaiters,
  assistQueue,
  sweep;

# Test only
NONE < testR, testW;

NONE < timerSend;

# Scheduler, timers, netpoll
NONE < allocmW, execW, cpuprof, pollCache, pollDesc, wakeableSleep;
scavenge, sweep, testR, wakeableSleep, timerSend < hchan;
assistQueue,
  cpuprof,

	if test {
		// Set up the scavenge index via sysAlloc so the test can free it later.
		scavIndexSize := uintptr(len(scavengeIndexArray)) * unsafe.Sizeof(atomicScavChunkData{})
		s.chunks = ((*[(1 << heapAddrBits) / pallocChunkBytes]atomicScavChunkData)(sysAlloc(scavIndexSize, sysStat)))[:]
		mappedReady = scavIndexSize
	} else {
		// Set up the scavenge index.
		s.chunks = scavengeIndexArray[:]
	}

	},
	{
		Name: "/cpu/classes/scavenge/total:cpu-seconds",
		Description: "Estimated total CPU time spent performing tasks that return " +
			"unused memory to the underlying platform. " +
			"This metric is an overestimate, and not directly comparable to " +
			"system CPU time measurements. Compare only with other /cpu/classes " +
			"metrics. Sum of all metrics in /cpu/classes/scavenge.",
		Kind:       KindFloat64,

	// susceptible to collection.
	big = nil

	// FreeOSMemory runs a GC cycle before releasing memory,
	// so it's fine to skip a GC here.
	//
	// It's possible the background scavenger runs concurrently
	// with this function and does most of the work for it.
	// If that happens, it's OK. What we want is a test that fails
	// often if FreeOSMemory does not work correctly, and a test

	scavAssistCpu := scavenge.assistTime.Load()
	scavBgCpu := scavenge.backgroundTime.Load()

	// Update cumulative GC CPU stats.
	s.GCAssistTime += markAssistCpu
	s.GCDedicatedTime += markDedicatedCpu + markFractionalCpu
	s.GCIdleTime += markIdleCpu
	s.GCTotalTime += markAssistCpu + markDedicatedCpu + markFractionalCpu + markIdleCpu

	// Update cumulative scavenge CPU stats.

	/cpu/classes/scavenge/assist:cpu-seconds
		Estimated total CPU time spent returning unused memory to the
		underlying platform in response eagerly in response to memory
		pressure. This metric is an overestimate, and not directly
		comparable to system CPU time measurements. Compare only with
		other /cpu/classes metrics.

	/cpu/classes/scavenge/background:cpu-seconds

		case "/cpu/classes/idle:cpu-seconds":
			cpu.idle = samples[i].Value.Float64()
		case "/cpu/classes/scavenge/assist:cpu-seconds":
			cpu.scavengeAssist = samples[i].Value.Float64()
		case "/cpu/classes/scavenge/background:cpu-seconds":
			cpu.scavengeBg = samples[i].Value.Float64()
		case "/cpu/classes/scavenge/total:cpu-seconds":
			cpu.scavengeTotal = samples[i].Value.Float64()
		case "/cpu/classes/total:cpu-seconds":

	// Reset assist time and background time stats.
	//
	// Do this now, instead of at the start of the next GC cycle, because
	// these two may keep accumulating even if the GC is not active.
	scavenge.assistTime.Store(0)
	scavenge.backgroundTime.Store(0)

	// Reset idle time stat.
	sched.idleTime.Store(0)

	if work.userForced {
		memstats.numforcedgc++
	}