// or are locked to other goroutines due to use of runtime.LockOSThread.
//
// SetMaxThreads is useful mainly for limiting the damage done by
// programs that create an unbounded number of threads. The idea is
// to take down the program before it takes down the operating system.
func SetMaxThreads(threads int) int {
	return setMaxThreads(threads)
}

// SetPanicOnFault controls the runtime's behavior when a program faults

import (
	"time"
)

// 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

	//
	// This can only happen when ints are 64 bits, since on platforms
	// with 32 bit ints SetMaxThreads (which takes an int parameter)
	// cannot be given anything that will overflow an int32.
	//
	// Call SetMaxThreads with 1<<31, but only on 64 bit systems.
	nt := SetMaxThreads(1 << (30 + ^uint(0)>>63))
	SetMaxThreads(nt) // restore previous value

	sysMaxThreads, err := sys.GetMaxThreads()
	if err == nil {
		minioMaxThreads := (sysMaxThreads * 90) / 100
		// Only set max threads if it is greater than the default one
		if minioMaxThreads > 10000 {
			debug.SetMaxThreads(minioMaxThreads)
		}
	}

	var maxLimit uint64

	// Set open files limit to maximum.
	if _, maxLimit, err = sys.GetMaxOpenFileLimit(); err != nil {
		return err
	}

}

func StackOverflow() {
	var f func() byte
	f = func() byte {
		var buf [64 << 10]byte
		return buf[0] + f()
	}
	debug.SetMaxStack(1474560)
	f()
}

func ThreadExhaustion() {
	debug.SetMaxThreads(10)
	c := make(chan int)
	for i := 0; i < 100; i++ {
		go func() {
			runtime.LockOSThread()
			c <- 0
			select {}
		}()
		<-c
	}
}

func RecursivePanic() {
	func() {

		if err != nil {
			for j := 0; j < i; j++ {
				r[j].Close()
				w[j].Close()
			}
			t.Fatal(err)
		}
		r[i] = rp
		w[i] = wp
	}

	defer debug.SetMaxThreads(debug.SetMaxThreads(threads / 2))

	creading := make(chan bool, threads)
	cdone := make(chan bool, threads)
	for i := 0; i < threads; i++ {
		go func(i int) {
			var b [1]byte
			creading <- true

func (l *gList) pop() *g {
	gp := l.head.ptr()
	if gp != nil {
		l.head = gp.schedlink
	}
	return gp
}

//go:linkname setMaxThreads runtime/debug.setMaxThreads
func setMaxThreads(in int) (out int) {
	lock(&sched.lock)
	out = int(sched.maxmcount)
	if in > 0x7fffffff { // MaxInt32
		sched.maxmcount = 0x7fffffff
	} else {
		sched.maxmcount = int32(in)

		{"ParseBuildInfo", Func, 18},
		{"PrintStack", Func, 0},
		{"ReadBuildInfo", Func, 12},
		{"ReadGCStats", Func, 1},
		{"SetGCPercent", Func, 1},
		{"SetMaxStack", Func, 2},
		{"SetMaxThreads", Func, 2},
		{"SetMemoryLimit", Func, 19},
		{"SetPanicOnFault", Func, 3},
		{"SetTraceback", Func, 6},
		{"Stack", Func, 0},
		{"WriteHeapDump", Func, 3},
	},
	"runtime/metrics": {

pkg reflect, method (Value) Slice3(int, int, int) Value
pkg runtime, type MemStats struct, GCSys uint64
pkg runtime, type MemStats struct, OtherSys uint64
pkg runtime/debug, func SetMaxStack(int) int
pkg runtime/debug, func SetMaxThreads(int) int
pkg sort, func Stable(Interface)
pkg strings, func IndexByte(string, uint8) int
pkg sync/atomic, func SwapInt32(*int32, int32) int32
pkg sync/atomic, func SwapInt64(*int64, int64) int64