go/src/runtime/mgcpacer_test.go

func TestGcPacer(t *testing.T) {}

type gcExecTest

const minRate

func (e *gcExecTest) next() gcCycle {}

func (e *gcExecTest) check(t *testing.T, results []gcCycleResult) {}

type gcCycle

type gcCycleResult

func (r *gcCycleResult) goalRatio() float64 {}

func (r *gcCycleResult) runway() float64 {}

func (r *gcCycleResult) triggerRatio() float64 {}

func (r *gcCycleResult) String() string {}

func assertInEpsilon(t *testing.T, name string, a, b, epsilon float64) {}

func assertInRange(t *testing.T, name string, a, min, max float64) {}

type float64Stream

// constant returns a stream that generates the value c.
func constant(c float64) float64Stream {}

// unit returns a stream that generates a single peak with
// amplitude amp, followed by zeroes.
//
// In another manner of speaking, this is the Kronecker delta.
func unit(amp float64) float64Stream {}

// oscillate returns a stream that oscillates sinusoidally
// with the given amplitude, phase, and period.
func oscillate(amp, phase float64, period int) float64Stream {}

// ramp returns a stream that moves from zero to height
// over the course of length steps.
func ramp(height float64, length int) float64Stream {}

// random returns a stream that generates random numbers
// between -amp and amp.
func random(amp float64, seed int64) float64Stream {}

// delay returns a new stream which is a buffered version
// of f: it returns zero for cycles steps, followed by f.
func (f float64Stream) delay(cycles int) float64Stream {}

// scale returns a new stream that is f, but attenuated by a
// constant factor.
func (f float64Stream) scale(amt float64) float64Stream {}

// offset returns a new stream that is f but offset by amt
// at each step.
func (f float64Stream) offset(amt float64) float64Stream {}

// sum returns a new stream that is the sum of all input streams
// at each step.
func (f float64Stream) sum(fs ...float64Stream) float64Stream {}

// quantize returns a new stream that rounds f to a multiple
// of mult at each step.
func (f float64Stream) quantize(mult float64) float64Stream {}

// min returns a new stream that replaces all values produced
// by f lower than min with min.
func (f float64Stream) min(min float64) float64Stream {}

// max returns a new stream that replaces all values produced
// by f higher than max with max.
func (f float64Stream) max(max float64) float64Stream {}

// limit returns a new stream that replaces all values produced
// by f lower than min with min and higher than max with max.
func (f float64Stream) limit(min, max float64) float64Stream {}

func applyMemoryLimitHeapGoalHeadroom(goal uint64) uint64 {}

func TestIdleMarkWorkerCount(t *testing.T) {}