const myLimit = 256 << 20
	if limit := debug.SetMemoryLimit(-1); limit != math.MaxInt64 {
		print("expected MaxInt64 limit, got ", limit, " bytes instead\n")
		return
	}
	if limit := debug.SetMemoryLimit(myLimit); limit != math.MaxInt64 {
		print("expected MaxInt64 limit, got ", limit, " bytes instead\n")
		return
	}
	if limit := debug.SetMemoryLimit(-1); limit != myLimit {

// two: KiB means 2^10 bytes, MiB means 2^20 bytes, and so on.
//
// SetMemoryLimit returns the previously set memory limit.
// A negative input does not adjust the limit, and allows for
// retrieval of the currently set memory limit.
func SetMemoryLimit(limit int64) int64 {
	return setMemoryLimit(limit)

// Implemented in package runtime.
func readGCStats(*[]time.Duration)
func freeOSMemory()
func setMaxStack(int) int
func setGCPercent(int32) int32
func setPanicOnFault(bool) bool
func setMaxThreads(int) int

			humanize.IBytes(vssLimit))
	}

	if ctx.MemLimit > 0 {
		maxLimit = ctx.MemLimit
	}

	if maxLimit > 0 {
		debug.SetMemoryLimit(int64(maxLimit))
	}

	// Do not use RLIMIT_AS as that is not useful and at times on systems < 4Gi
	// this can crash the Go runtime if the value is smaller refer
	// - https://github.com/golang/go/issues/38010

	if in >= 0 {
		c.memoryLimit.Store(in)
	}

	return out
}

//go:linkname setMemoryLimit runtime/debug.setMemoryLimit
func setMemoryLimit(in int64) (out int64) {
	// Run on the system stack since we grab the heap lock.
	systemstack(func() {
		lock(&mheap_.lock)
		out = gcController.setMemoryLimit(in)
		if in < 0 || out == in {
			// If we're just checking the value or not changing

	{
		Name: "/gc/gomemlimit:bytes",
		Description: "Go runtime memory limit configured by the user, otherwise " +
			"math.MaxInt64. This value is set by the GOMEMLIMIT environment variable, and " +
			"the runtime/debug.SetMemoryLimit function.",
		Kind: KindUint64,
	},
	{
		Name: "/gc/heap/allocs-by-size:bytes",
		Description: "Distribution of heap allocations by approximate size. " +
			"Bucket counts increase monotonically. " +

	/gc/gomemlimit:bytes
		Go runtime memory limit configured by the user, otherwise
		math.MaxInt64. This value is set by the GOMEMLIMIT environment
		variable, and the runtime/debug.SetMemoryLimit function.

	/gc/heap/allocs-by-size:bytes
		Distribution of heap allocations by approximate size.
		Bucket counts increase monotonically. Note that this does not

pkg os/exec, var ErrDot error #43724
pkg regexp/syntax, const ErrNestingDepth = "expression nests too deeply" #51684
pkg regexp/syntax, const ErrNestingDepth ErrorCode #51684
pkg runtime/debug, func SetMemoryLimit(int64) int64 #48409
pkg sort, func Find(int, func(int) int) (int, bool) #50340
pkg sync/atomic, method (*Bool) CompareAndSwap(bool, bool) bool #50860
pkg sync/atomic, method (*Bool) Load() bool #50860

they are based on powers of two: KiB means 2^10 bytes, MiB means 2^20 bytes,
and so on. The default setting is [math.MaxInt64], which effectively disables the
memory limit. [runtime/debug.SetMemoryLimit] allows changing this limit at run
time.

The GODEBUG variable controls debugging variables within the runtime.
It is a comma-separated list of name=val pairs setting these named variables:

	// Run a GC cycle to get some of the stats to be non-zero.
	runtime.GC()

	// Set an arbitrary memory limit to check the metric for it
	limit := int64(512 * 1024 * 1024)
	oldLimit := debug.SetMemoryLimit(limit)
	defer debug.SetMemoryLimit(oldLimit)

	// Set a GC percent to check the metric for it
	gcPercent := 99
	oldGCPercent := debug.SetGCPercent(gcPercent)
	defer debug.SetGCPercent(oldGCPercent)