newprocs = int32(n)

	startTheWorldGC(stw)
	return ret
}

// NumCPU returns the number of logical CPUs usable by the current process.
//
// The set of available CPUs is checked by querying the operating system
// at process startup. Changes to operating system CPU allocation after
// process startup are not reflected.
func NumCPU() int {
	return int(ncpu)
}

	}

	// NumCPU from FreeBSDNumCPUHelper come with '\n'.
	output = bytes.TrimSpace(output)
	n, err := strconv.Atoi(string(output))
	if err != nil {
		return fmt.Errorf("fail to parse output from child '%s', error: %s, output: %s", cmdline, err, output)
	}
	if n != len(list) {
		return fmt.Errorf("runtime.NumCPU() expected to %d, got %d when run with CPU list %s", len(list), n, cListString)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p1

import "runtime"

func E() func() int { return runtime.NumCPU }

func F() func() { return runtime.Gosched }

func G() func() string { return runtime.GOROOT }

func H() func() { return runtime.GC }

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p2

import "runtime"

func E() func() int { return runtime.NumCPU }

func F() func() { return runtime.GC }

func G() func() string { return runtime.GOROOT }

func H() func() { return runtime.Gosched }

			if s != tc.stats {
				t.Errorf("Got stats of %v, expected %v", s, tc.stats)
			}
		})
	}
}

func testCacheConcurrent(c Cache, t *testing.T) {
	wg := new(sync.WaitGroup)
	workers := runtime.NumCPU()
	wg.Add(workers)

	const numIters = 10000
	for i := 0; i < workers; i++ {
		workerNum := i
		go func() {
			for j := 0; j < numIters; j++ {

			TotalAlloc: memstats.TotalAlloc,
			Mallocs:    memstats.Mallocs,
			Frees:      memstats.Frees,
			HeapAlloc:  memstats.HeapAlloc,
		},
		GoMaxProcs:     runtime.GOMAXPROCS(0),
		NumCPU:         runtime.NumCPU(),
		RuntimeVersion: runtime.Version(),
		GCStats: &madmin.GCStats{
			LastGC:     gcStats.LastGC,
			NumGC:      gcStats.NumGC,
			PauseTotal: gcStats.PauseTotal,
			Pause:      gcStats.Pause,

	return nil, fmt.Errorf("event object not of type node")
}

func detectNumCPU() int {
	// try get numCPU from /sys firstly due to a known issue (https://github.com/kubernetes/kubernetes/issues/99225)
	_, numCPU, err := machine.GetTopology(sysfs.NewRealSysFs())
	if err != nil || numCPU < 1 {
		return goruntime.NumCPU()
	}
	return numCPU
}

	"runtime"
)

const N = 100000

func main() {
	// Allocate more Ps than processors.  This raises
	// the chance that we get interrupted by the OS
	// in exactly the right (wrong!) place.
	p := runtime.NumCPU()
	runtime.GOMAXPROCS(2 * p)

	// Allocate some pointers.
	ptrs := make([]*int, p)
	for i := 0; i < p; i++ {
		ptrs[i] = new(int)
	}

	// Arena where we read and write pointers like crazy.

type NumCPUCheck struct {
	NumCPU int
}

// Name returns the label for NumCPUCheck
func (NumCPUCheck) Name() string {
	return "NumCPU"
}

// Check number of CPUs required by kubeadm
func (ncc NumCPUCheck) Check() (warnings, errorList []error) {
	numCPU := runtime.NumCPU()
	if numCPU < ncc.NumCPU {

	}

	if proxyConfig.Concurrency.GetValue() == 0 {
		if CPULimit < runtime.NumCPU() {
			log.Warnf("concurrency is set to 0, which will use a thread per CPU on the host. However, CPU limit is set lower. "+
				"This is not recommended and may lead to performance issues. "+
				"CPU count: %d, CPU Limit: %d.", runtime.NumCPU(), CPULimit)
		}
	}