src/cmd/compile/internal/base/startheap.go - go - Git at Google

 // Copyright 2025 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package base

 import (
 	"fmt"
 	"os"
 	"runtime"
 	"runtime/debug"
 	"runtime/metrics"
 	"sync"
 )

 // forEachGC calls fn each GC cycle until it returns false.
 func forEachGC(fn func() bool) {
 	type T [32]byte // large enough to avoid runtime's tiny object allocator
 	var finalizer func(*T)
 	finalizer = func(p *T) {

 		if fn() {
 			runtime.SetFinalizer(p, finalizer)
 		}
 	}

 	finalizer(new(T))
 }

 // AdjustStartingHeap modifies GOGC so that GC should not occur until the heap
 // grows to the requested size.  This is intended but not promised, though it
 // is true-mostly, depending on when the adjustment occurs and on the
 // compiler's input and behavior.  Once the live heap is approximately half
 // this size, GOGC is reset to its value when AdjustStartingHeap was called;
 // subsequent GCs may reduce the heap below the requested size, but this
 // function does not affect that.
 //
 // logHeapTweaks (-d=gcadjust=1) enables logging of GOGC adjustment events.
 //
 // The temporarily requested GOGC is derated from what would be the "obvious"
 // value necessary to hit the starting heap goal because the obvious
 // (goal/live-1)*100 value seems to grow RSS a little more than it "should"
 // (compared to GOMEMLIMIT, e.g.) and the assumption is that the GC's control
 // algorithms are tuned for GOGC near 100, and not tuned for huge values of
 // GOGC.  Different derating factors apply for "lo" and "hi" values of GOGC;
 // lo is below derateBreak, hi is above derateBreak.  The derating factors,
 // expressed as integer percentages, are derateLoPct and derateHiPct.
 // 60-75 is an okay value for derateLoPct, 30-65 seems like a good value for
 // derateHiPct, and 600 seems like a good value for derateBreak.  If these
 // are zero, defaults are used instead.
 //
 // NOTE: If you think this code would help startup time in your own
 // application and you decide to use it, please benchmark first to see if it
 // actually works for you (it may not: the Go compiler is not typical), and
 // whatever the outcome, please leave a comment on bug #56546.  This code
 // uses supported interfaces, but depends more than we like on
 // current+observed behavior of the garbage collector, so if many people need
 // this feature, we should consider/propose a better way to accomplish it.
 func AdjustStartingHeap(requestedHeapGoal, derateBreak, derateLoPct, derateHiPct uint64, logHeapTweaks bool) {
 	mp := runtime.GOMAXPROCS(0)

 	const (
 		SHgoal   = "/gc/heap/goal:bytes"
 		SHcount  = "/gc/cycles/total:gc-cycles"
 		SHallocs = "/gc/heap/allocs:bytes"
 		SHfrees  = "/gc/heap/frees:bytes"
 	)

 	var sample = []metrics.Sample{{Name: SHgoal}, {Name: SHcount}, {Name: SHallocs}, {Name: SHfrees}}

 	const (
 		SH_GOAL   = 0
 		SH_COUNT  = 1
 		SH_ALLOCS = 2
 		SH_FREES  = 3

 		MB = 1_000_000
 	)

 	// These particular magic numbers are designed to make the RSS footprint of -d=-gcstart=2000
 	// resemble that of GOMEMLIMIT=2000MiB GOGC=10000 when building large projects
 	// (e.g. the Go compiler itself, and the microsoft's typescript AST package),
 	// with the further restriction that these magic numbers did a good job of reducing user-cpu
 	// for builds at either gcstart=2000 or gcstart=128.
 	//
 	// The benchmarking to obtain this was (a version of):
 	//
 	// for i in {1..50} ; do
 	//     for what in std cmd/compile cmd/fix cmd/go github.com/microsoft/typescript-go/internal/ast ; do
 	//       whatbase=`basename ${what}`
 	//       for sh in 128 2000 ; do
 	//         for br in 500 600 ; do
 	//           for shlo in 65 70; do
 	//             for shhi in 55 60 ; do
 	//               benchcmd -n=2 ${whatbase} go build -a \
 	//               -gcflags=all=-d=gcstart=${sh},gcstartloderate=${shlo},gcstarthiderate=${shhi},gcstartbreak=${br} \
 	//               ${what} | tee -a startheap${sh}_${br}_${shhi}_${shlo}.bench
 	//             done
 	//           done
 	//         done
 	//       done
 	//     done
 	// done
 	//
 	// benchcmd is "go install github.com/aclements/go-misc/benchcmd@latest"

 	if derateBreak == 0 {
 		derateBreak = 600
 	}
 	if derateLoPct == 0 {
 		derateLoPct = 70
 	}
 	if derateHiPct == 0 {
 		derateHiPct = 55
 	}

 	gogcDerate := func(myGogc uint64) uint64 {
 		if myGogc < derateBreak {
 			return (myGogc * derateLoPct) / 100
 		}
 		return (myGogc * derateHiPct) / 100
 	}

 	// Assumptions and observations of Go's garbage collector, as of Go 1.17-1.20:

 	// - the initial heap goal is 4MiB, by fiat.  It is possible for Go to start
 	//   with a heap as small as 512k, so this may change in the future.

 	// - except for the first heap goal, heap goal is a function of
 	//   observed-live at the previous GC and current GOGC.  After the first
 	//   GC, adjusting GOGC immediately updates GOGC; before the first GC,
 	//   adjusting GOGC does not modify goal (but the change takes effect after
 	//   the first GC).

 	// - the before/after first GC behavior is not guaranteed anywhere, it's
 	//   just behavior, and it's a bad idea to rely on it.

 	// - we don't know exactly when GC will run, even after we adjust GOGC; the
 	//   first GC may not have happened yet, may have already happened, or may
 	//   be currently in progress, and GCs can start for several reasons.

 	// - forEachGC above will run the provided function at some delay after each
 	//   GC's mark phase terminates; finalizers are run after marking as the
 	//   spans containing finalizable objects are swept, driven by GC
 	//   background activity and allocation demand.

 	// - "live at last GC" is not available through the current metrics
 	//    interface. Instead, live is estimated by knowing the adjusted value of
 	//    GOGC and the new heap goal following a GC (this requires knowing that
 	//    at least one GC has occurred):
 	//		  estLive = 100 * newGoal / (100 + currentGogc)
 	//    this new value of GOGC
 	//		  newGogc = 100*requestedHeapGoal/estLive - 100
 	//    will result in the desired goal. The logging code checks that the
 	//    resulting goal is correct.

 	// There's a small risk that the finalizer will be slow to run after a GC
 	// that expands the goal to a huge value, and that this will lead to
 	// out-of-memory.  This doesn't seem to happen; in experiments on a variety
 	// of machines with a variety of extra loads to disrupt scheduling, the
 	// worst overshoot observed was 50% past requestedHeapGoal.

 	metrics.Read(sample)
 	for _, s := range sample {
 		if s.Value.Kind() == metrics.KindBad {
 			// Just return, a slightly slower compilation is a tolerable outcome.
 			if logHeapTweaks {
 				fmt.Fprintf(os.Stderr, "GCAdjust: Regret unexpected KindBad for metric %s\n", s.Name)
 			}
 			return
 		}
 	}

 	// Tinker with GOGC to make the heap grow rapidly at first.
 	currentGoal := sample[SH_GOAL].Value.Uint64() // Believe this will be 4MByte or less, perhaps 512k
 	myGogc := 100 * requestedHeapGoal / currentGoal
 	myGogc = gogcDerate(myGogc)
 	if myGogc <= 125 {
 		return
 	}

 	if logHeapTweaks {
 		sample := append([]metrics.Sample(nil), sample...) // avoid races with GC callback
 		AtExit(func() {
 			metrics.Read(sample)
 			goal := sample[SH_GOAL].Value.Uint64()
 			count := sample[SH_COUNT].Value.Uint64()
 			oldGogc := debug.SetGCPercent(100)
 			if oldGogc == 100 {
 				fmt.Fprintf(os.Stderr, "GCAdjust: AtExit goal %dMB gogc %d count %d maxprocs %d\n",
 					goal/MB, oldGogc, count, mp)
 			} else {
 				inUse := sample[SH_ALLOCS].Value.Uint64() - sample[SH_FREES].Value.Uint64()
 				overPct := 100 * (int(inUse) - int(requestedHeapGoal)) / int(requestedHeapGoal)
 				fmt.Fprintf(os.Stderr, "GCAdjust: AtExit goal %dMB gogc %d count %d maxprocs %d overPct %d\n",
 					goal/MB, oldGogc, count, mp, overPct)

 			}
 		})
 	}

 	originalGOGC := debug.SetGCPercent(int(myGogc))

 	// forEachGC finalizers ought not overlap, but they could run in separate threads.
 	// This ought not matter, but just in case it bothers the/a race detector,
 	// use this mutex.
 	var forEachGCLock sync.Mutex

 	adjustFunc := func() bool {

 		forEachGCLock.Lock()
 		defer forEachGCLock.Unlock()

 		metrics.Read(sample)
 		goal := sample[SH_GOAL].Value.Uint64()
 		count := sample[SH_COUNT].Value.Uint64()

 		if goal <= requestedHeapGoal { // Stay the course
 			if logHeapTweaks {
 				fmt.Fprintf(os.Stderr, "GCAdjust: Reuse GOGC adjust, current goal %dMB, count is %d, current gogc %d\n",
 					goal/MB, count, myGogc)
 			}
 			return true
 		}

 		// Believe goal has been adjusted upwards, else it would be less-than-or-equal to requestedHeapGoal
 		calcLive := 100 * goal / (100 + myGogc)

 		if 2*calcLive < requestedHeapGoal { // calcLive can exceed requestedHeapGoal!
 			myGogc = 100*requestedHeapGoal/calcLive - 100
 			myGogc = gogcDerate(myGogc)

 			if myGogc > 125 {
 				// Not done growing the heap.
 				oldGogc := debug.SetGCPercent(int(myGogc))

 				if logHeapTweaks {
 					// Check that the new goal looks right
 					inUse := sample[SH_ALLOCS].Value.Uint64() - sample[SH_FREES].Value.Uint64()
 					metrics.Read(sample)
 					newGoal := sample[SH_GOAL].Value.Uint64()
 					pctOff := 100 * (int64(newGoal) - int64(requestedHeapGoal)) / int64(requestedHeapGoal)
 					// Check that the new goal is close to requested.  3% of make.bash fails this test.  Why, TBD.
 					if pctOff < 2 {
 						fmt.Fprintf(os.Stderr, "GCAdjust: Retry GOGC adjust, current goal %dMB, count is %d, gogc was %d, is now %d, calcLive %dMB pctOff %d\n",
 							goal/MB, count, oldGogc, myGogc, calcLive/MB, pctOff)
 					} else {
 						// The GC is being annoying and not giving us the goal that we requested, say more to help understand when/why.
 						fmt.Fprintf(os.Stderr, "GCAdjust: Retry GOGC adjust, current goal %dMB, count is %d, gogc was %d, is now %d, calcLive %dMB pctOff %d inUse %dMB\n",
 							goal/MB, count, oldGogc, myGogc, calcLive/MB, pctOff, inUse/MB)
 					}
 				}
 				return true
 			}
 		}

 		// In this case we're done boosting GOGC, set it to its original value and don't set a new finalizer.
 		oldGogc := debug.SetGCPercent(originalGOGC)
 		// inUse helps estimate how late the finalizer ran; at the instant the previous GC ended,
 		// it was (in theory) equal to the previous GC's heap goal.  In a growing heap it is
 		// expected to grow to the new heap goal.
 		if logHeapTweaks {
 			inUse := sample[SH_ALLOCS].Value.Uint64() - sample[SH_FREES].Value.Uint64()
 			overPct := 100 * (int(inUse) - int(requestedHeapGoal)) / int(requestedHeapGoal)
 			fmt.Fprintf(os.Stderr, "GCAdjust: Reset GOGC adjust, old goal %dMB, count is %d, gogc was %d, gogc is now %d, calcLive %dMB inUse %dMB overPct %d\n",
 				goal/MB, count, oldGogc, originalGOGC, calcLive/MB, inUse/MB, overPct)
 		}
 		return false
 	}

 	forEachGC(adjustFunc)
 }
	// Copyright 2025 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package base

	import (
	"fmt"
	"os"
	"runtime"
	"runtime/debug"
	"runtime/metrics"
	"sync"
	)

	// forEachGC calls fn each GC cycle until it returns false.
	func forEachGC(fn func() bool) {
	type T [32]byte // large enough to avoid runtime's tiny object allocator
	var finalizer func(*T)
	finalizer = func(p *T) {

	if fn() {
	runtime.SetFinalizer(p, finalizer)
	}
	}

	finalizer(new(T))
	}

	// AdjustStartingHeap modifies GOGC so that GC should not occur until the heap
	// grows to the requested size. This is intended but not promised, though it
	// is true-mostly, depending on when the adjustment occurs and on the
	// compiler's input and behavior. Once the live heap is approximately half
	// this size, GOGC is reset to its value when AdjustStartingHeap was called;
	// subsequent GCs may reduce the heap below the requested size, but this
	// function does not affect that.
	//
	// logHeapTweaks (-d=gcadjust=1) enables logging of GOGC adjustment events.
	//
	// The temporarily requested GOGC is derated from what would be the "obvious"
	// value necessary to hit the starting heap goal because the obvious
	// (goal/live-1)*100 value seems to grow RSS a little more than it "should"
	// (compared to GOMEMLIMIT, e.g.) and the assumption is that the GC's control
	// algorithms are tuned for GOGC near 100, and not tuned for huge values of
	// GOGC. Different derating factors apply for "lo" and "hi" values of GOGC;
	// lo is below derateBreak, hi is above derateBreak. The derating factors,
	// expressed as integer percentages, are derateLoPct and derateHiPct.
	// 60-75 is an okay value for derateLoPct, 30-65 seems like a good value for
	// derateHiPct, and 600 seems like a good value for derateBreak. If these
	// are zero, defaults are used instead.
	//
	// NOTE: If you think this code would help startup time in your own
	// application and you decide to use it, please benchmark first to see if it
	// actually works for you (it may not: the Go compiler is not typical), and
	// whatever the outcome, please leave a comment on bug #56546. This code
	// uses supported interfaces, but depends more than we like on
	// current+observed behavior of the garbage collector, so if many people need
	// this feature, we should consider/propose a better way to accomplish it.
	func AdjustStartingHeap(requestedHeapGoal, derateBreak, derateLoPct, derateHiPct uint64, logHeapTweaks bool) {
	mp := runtime.GOMAXPROCS(0)

	const (
	SHgoal = "/gc/heap/goal:bytes"
	SHcount = "/gc/cycles/total:gc-cycles"
	SHallocs = "/gc/heap/allocs:bytes"
	SHfrees = "/gc/heap/frees:bytes"
	)

	var sample = []metrics.Sample{{Name: SHgoal}, {Name: SHcount}, {Name: SHallocs}, {Name: SHfrees}}

	const (
	SH_GOAL = 0
	SH_COUNT = 1
	SH_ALLOCS = 2
	SH_FREES = 3

	MB = 1_000_000
	)

	// These particular magic numbers are designed to make the RSS footprint of -d=-gcstart=2000
	// resemble that of GOMEMLIMIT=2000MiB GOGC=10000 when building large projects
	// (e.g. the Go compiler itself, and the microsoft's typescript AST package),
	// with the further restriction that these magic numbers did a good job of reducing user-cpu
	// for builds at either gcstart=2000 or gcstart=128.
	//
	// The benchmarking to obtain this was (a version of):
	//
	// for i in {1..50} ; do
	// for what in std cmd/compile cmd/fix cmd/go github.com/microsoft/typescript-go/internal/ast ; do
	// whatbase=`basename ${what}`
	// for sh in 128 2000 ; do
	// for br in 500 600 ; do
	// for shlo in 65 70; do
	// for shhi in 55 60 ; do
	// benchcmd -n=2 ${whatbase} go build -a \
	// -gcflags=all=-d=gcstart=${sh},gcstartloderate=${shlo},gcstarthiderate=${shhi},gcstartbreak=${br} \
	// ${what} \| tee -a startheap${sh}_${br}_${shhi}_${shlo}.bench
	// done
	// done
	// done
	// done
	// done
	// done
	//
	// benchcmd is "go install github.com/aclements/go-misc/benchcmd@latest"

	if derateBreak == 0 {
	derateBreak = 600
	}
	if derateLoPct == 0 {
	derateLoPct = 70
	}
	if derateHiPct == 0 {
	derateHiPct = 55
	}

	gogcDerate := func(myGogc uint64) uint64 {
	if myGogc < derateBreak {
	return (myGogc * derateLoPct) / 100
	}
	return (myGogc * derateHiPct) / 100
	}

	// Assumptions and observations of Go's garbage collector, as of Go 1.17-1.20:

	// - the initial heap goal is 4MiB, by fiat. It is possible for Go to start
	// with a heap as small as 512k, so this may change in the future.

	// - except for the first heap goal, heap goal is a function of
	// observed-live at the previous GC and current GOGC. After the first
	// GC, adjusting GOGC immediately updates GOGC; before the first GC,
	// adjusting GOGC does not modify goal (but the change takes effect after
	// the first GC).

	// - the before/after first GC behavior is not guaranteed anywhere, it's
	// just behavior, and it's a bad idea to rely on it.

	// - we don't know exactly when GC will run, even after we adjust GOGC; the
	// first GC may not have happened yet, may have already happened, or may
	// be currently in progress, and GCs can start for several reasons.

	// - forEachGC above will run the provided function at some delay after each
	// GC's mark phase terminates; finalizers are run after marking as the
	// spans containing finalizable objects are swept, driven by GC
	// background activity and allocation demand.

	// - "live at last GC" is not available through the current metrics
	// interface. Instead, live is estimated by knowing the adjusted value of
	// GOGC and the new heap goal following a GC (this requires knowing that
	// at least one GC has occurred):
	// estLive = 100 * newGoal / (100 + currentGogc)
	// this new value of GOGC
	// newGogc = 100*requestedHeapGoal/estLive - 100
	// will result in the desired goal. The logging code checks that the
	// resulting goal is correct.

	// There's a small risk that the finalizer will be slow to run after a GC
	// that expands the goal to a huge value, and that this will lead to
	// out-of-memory. This doesn't seem to happen; in experiments on a variety
	// of machines with a variety of extra loads to disrupt scheduling, the
	// worst overshoot observed was 50% past requestedHeapGoal.

	metrics.Read(sample)
	for _, s := range sample {
	if s.Value.Kind() == metrics.KindBad {
	// Just return, a slightly slower compilation is a tolerable outcome.
	if logHeapTweaks {
	fmt.Fprintf(os.Stderr, "GCAdjust: Regret unexpected KindBad for metric %s\n", s.Name)
	}
	return
	}
	}

	// Tinker with GOGC to make the heap grow rapidly at first.
	currentGoal := sample[SH_GOAL].Value.Uint64() // Believe this will be 4MByte or less, perhaps 512k
	myGogc := 100 * requestedHeapGoal / currentGoal
	myGogc = gogcDerate(myGogc)
	if myGogc <= 125 {
	return
	}

	if logHeapTweaks {
	sample := append([]metrics.Sample(nil), sample...) // avoid races with GC callback
	AtExit(func() {
	metrics.Read(sample)
	goal := sample[SH_GOAL].Value.Uint64()
	count := sample[SH_COUNT].Value.Uint64()
	oldGogc := debug.SetGCPercent(100)
	if oldGogc == 100 {
	fmt.Fprintf(os.Stderr, "GCAdjust: AtExit goal %dMB gogc %d count %d maxprocs %d\n",
	goal/MB, oldGogc, count, mp)
	} else {
	inUse := sample[SH_ALLOCS].Value.Uint64() - sample[SH_FREES].Value.Uint64()
	overPct := 100 * (int(inUse) - int(requestedHeapGoal)) / int(requestedHeapGoal)
	fmt.Fprintf(os.Stderr, "GCAdjust: AtExit goal %dMB gogc %d count %d maxprocs %d overPct %d\n",
	goal/MB, oldGogc, count, mp, overPct)

	}
	})
	}

	originalGOGC := debug.SetGCPercent(int(myGogc))

	// forEachGC finalizers ought not overlap, but they could run in separate threads.
	// This ought not matter, but just in case it bothers the/a race detector,
	// use this mutex.
	var forEachGCLock sync.Mutex

	adjustFunc := func() bool {

	forEachGCLock.Lock()
	defer forEachGCLock.Unlock()

	metrics.Read(sample)
	goal := sample[SH_GOAL].Value.Uint64()
	count := sample[SH_COUNT].Value.Uint64()

	if goal <= requestedHeapGoal { // Stay the course
	if logHeapTweaks {
	fmt.Fprintf(os.Stderr, "GCAdjust: Reuse GOGC adjust, current goal %dMB, count is %d, current gogc %d\n",
	goal/MB, count, myGogc)
	}
	return true
	}

	// Believe goal has been adjusted upwards, else it would be less-than-or-equal to requestedHeapGoal
	calcLive := 100 * goal / (100 + myGogc)

	if 2*calcLive < requestedHeapGoal { // calcLive can exceed requestedHeapGoal!
	myGogc = 100*requestedHeapGoal/calcLive - 100
	myGogc = gogcDerate(myGogc)

	if myGogc > 125 {
	// Not done growing the heap.
	oldGogc := debug.SetGCPercent(int(myGogc))

	if logHeapTweaks {
	// Check that the new goal looks right
	inUse := sample[SH_ALLOCS].Value.Uint64() - sample[SH_FREES].Value.Uint64()
	metrics.Read(sample)
	newGoal := sample[SH_GOAL].Value.Uint64()
	pctOff := 100 * (int64(newGoal) - int64(requestedHeapGoal)) / int64(requestedHeapGoal)
	// Check that the new goal is close to requested. 3% of make.bash fails this test. Why, TBD.
	if pctOff < 2 {
	fmt.Fprintf(os.Stderr, "GCAdjust: Retry GOGC adjust, current goal %dMB, count is %d, gogc was %d, is now %d, calcLive %dMB pctOff %d\n",
	goal/MB, count, oldGogc, myGogc, calcLive/MB, pctOff)
	} else {
	// The GC is being annoying and not giving us the goal that we requested, say more to help understand when/why.
	fmt.Fprintf(os.Stderr, "GCAdjust: Retry GOGC adjust, current goal %dMB, count is %d, gogc was %d, is now %d, calcLive %dMB pctOff %d inUse %dMB\n",
	goal/MB, count, oldGogc, myGogc, calcLive/MB, pctOff, inUse/MB)
	}
	}
	return true
	}
	}

	// In this case we're done boosting GOGC, set it to its original value and don't set a new finalizer.
	oldGogc := debug.SetGCPercent(originalGOGC)
	// inUse helps estimate how late the finalizer ran; at the instant the previous GC ended,
	// it was (in theory) equal to the previous GC's heap goal. In a growing heap it is
	// expected to grow to the new heap goal.
	if logHeapTweaks {
	inUse := sample[SH_ALLOCS].Value.Uint64() - sample[SH_FREES].Value.Uint64()
	overPct := 100 * (int(inUse) - int(requestedHeapGoal)) / int(requestedHeapGoal)
	fmt.Fprintf(os.Stderr, "GCAdjust: Reset GOGC adjust, old goal %dMB, count is %d, gogc was %d, gogc is now %d, calcLive %dMB inUse %dMB overPct %d\n",
	goal/MB, count, oldGogc, originalGOGC, calcLive/MB, inUse/MB, overPct)
	}
	return false
	}

	forEachGC(adjustFunc)
	}