《Go 语言运行时原理》6.3 Green Tea GC 实测对比

$ GOTOOLCHAIN=go1.27.0 go env GOEXPERIMENT

$ GOTOOLCHAIN=go1.27.0 go build -o gt_on .
$ GOTOOLCHAIN=go1.27.0 go tool nm gt_on | grep 'tryDeferToSpanScan\|spanInlineMarkBits'
100029550 T runtime.(*spanInlineMarkBits).init
1000295e0 T runtime.(*spanInlineMarkBits).tryAcquire
100029770 T runtime.tryDeferToSpanScan

$ GOTOOLCHAIN=go1.27.0 GOEXPERIMENT=nogreenteagc go build -o gt_off .
$ GOTOOLCHAIN=go1.27.0 go tool nm gt_off | grep -c 'tryDeferToSpanScan\|spanInlineMarkBits'
0

	baseline := goexperiment.Flags{
		RegabiWrappers:        regabiSupported,
		RegabiArgs:            regabiSupported,
		Dwarf5:                dwarf5Supported,
		RandomizedHeapBase64:  true,
		GreenTeaGC:            true,
		JSONv2:                true,
		SizeSpecializedMalloc: true,
	}

type Node struct {
	left, right *Node
	val         int
	pad         [5]int
}

func build(depth int) *Node {
	if depth == 0 {
		return &Node{val: 1}
	}
	return &Node{left: build(depth - 1), right: build(depth - 1), val: depth}
}

func main() {
	samples := []metrics.Sample{{Name: "/cpu/classes/gc/total:cpu-seconds"}}
	metrics.Read(samples)
	before := samples[0].Value.Float64()

	start := time.Now()
	for i := 0; i < 40; i++ {
		root := build(17)
		runtime.KeepAlive(root)
	}
	wall := time.Since(start)

	metrics.Read(samples)
	gcCPU := samples[0].Value.Float64() - before
	fmt.Printf("wall=%v gcCPU=%v\n", wall, gcCPU)
}

$ for i in $(seq 9); do GOTOOLCHAIN=go1.27.0 ./gt_on; done
wall=0.144s gcCPU=0.059s
wall=0.146s gcCPU=0.061s
wall=0.147s gcCPU=0.062s
wall=0.145s gcCPU=0.060s
wall=0.146s gcCPU=0.061s
wall=0.143s gcCPU=0.058s
wall=0.148s gcCPU=0.063s
wall=0.146s gcCPU=0.061s
wall=0.147s gcCPU=0.062s

$ for i in $(seq 9); do GOTOOLCHAIN=go1.27.0 GOEXPERIMENT=nogreenteagc ./gt_off; done
wall=0.157s gcCPU=0.192s
wall=0.161s gcCPU=0.198s
wall=0.158s gcCPU=0.194s
wall=0.160s gcCPU=0.197s
wall=0.159s gcCPU=0.195s
wall=0.156s gcCPU=0.190s
wall=0.162s gcCPU=0.199s
wall=0.159s gcCPU=0.196s
wall=0.160s gcCPU=0.194s

// Green Tea mark algorithm
//
// The core idea behind Green Tea is simple: achieve better locality during
// mark/scan by delaying scanning so that we can accumulate objects to scan
// within the same span, then scan the objects that have accumulated on the
// span all together.
//
// By batching objects this way, we increase the chance that adjacent objects
// will be accessed, amortize the cost of accessing object metadata, and create
// better opportunities for prefetching. ...
//
// Naturally, this depends on being able to create opportunities to batch objects
// together. The basic idea here is to have two sets of mark bits. One set is the
// regular set of mark bits ("marks"), while the other essentially says that the
// objects have been scanned already ("scans"). When we see a pointer for the first
// time we set its mark and enqueue its span. We track these spans in work queues
// with a FIFO policy, unlike workbufs which have a LIFO policy. Empirically, a
// FIFO policy appears to work best for accumulating objects to scan on a span.

func gcUsesSpanInlineMarkBits(size uintptr) bool {
	return heapBitsInSpan(size) && size >= 16
}

func tryDeferToSpanScan(p uintptr, gcw *gcWork) bool {
	if useCheckmark {
		return false
	}
	// Quickly to see if this is a span that has inline mark bits.
	ha := heapArenaOf(p)
	if ha == nil {
		return false
	}
	pageIdx := ((p / pageSize) / 8) % uintptr(len(ha.pageInUse))
	pageMask := byte(1 << ((p / pageSize) % 8))
	if ha.pageUseSpanInlineMarkBits[pageIdx]&pageMask == 0 {
		return false
	}
	...
}

			if gcphase == _GCmark {
				// This is intentionally racy; the bit set here might get
				// stomped on by a stealing P. See the comment in tryStealSpan
				// for an explanation as to why this is OK.
				if !work.spanqMask.read(uint32(gcw.id)) {
					work.spanqMask.set(gcw.id)
				}
				gcw.mayNeedWorker = true
			}