func BenchmarkCopyElim100(b *testing.B)    { benchmarkCopyElim(b, 100) }
func BenchmarkCopyElim1000(b *testing.B)   { benchmarkCopyElim(b, 1000) }
func BenchmarkCopyElim10000(b *testing.B)  { benchmarkCopyElim(b, 10000) }
func BenchmarkCopyElim100000(b *testing.B) { benchmarkCopyElim(b, 100000) }

func benchmarkCopyElim(b *testing.B, n int) {
	c := testConfig(b)

	values := make([]interface{}, 0, n+2)

iptables -t nat -A ISTIO_OUTPUT -o lo -m owner ! --gid-owner 1337 -j RETURN
iptables -t nat -A ISTIO_OUTPUT -m owner --gid-owner 1337 -j RETURN
iptables -t nat -A ISTIO_OUTPUT -d 127.0.0.1/32 -j RETURN
iptables -t nat -A ISTIO_OUTPUT -d 10.0.0.0/8 -j ISTIO_REDIRECT

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

package main

import (
	"fmt"
	"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)

					"fakeContainer100": cpuset.New(1, 2, 3),
				},
			},
			stDefaultCPUSet: cpuset.New(0, 4, 5, 6, 7, 8, 9, 10, 11),
			pod:             makePod("fakePod", "fakeContainer5", "10000m", "10000m"),
			expErr:          fmt.Errorf("not enough cpus available to satisfy request: requested=10, available=8"),
			expCPUAlloc:     false,
			expCSet:         cpuset.New(),
		},
		{

                                                   value="${f:h(errorCountMin)}" class="form-control"
                                                   min="0" max="100000">
                                        </div>
                                        <div class="mx-sm-2">-</div>
                                        <div>

			// CPU Score: ((4000 - 0) * MaxNodeScore) / 4000 = MaxNodeScore
			// Memory Score: ((10000 - 0) * MaxNodeScore) / 10000 = MaxNodeScore
			// Node1 Score: (100 + 100) / 2 = 100
			// Node2 scores (remaining resources) on 0-MaxNodeScore scale
			// CPU Score: ((4000 - 0) * MaxNodeScore) / 4000 = MaxNodeScore
			// Memory Score: ((10000 - 0) * MaxNodeScore) / 10000 = MaxNodeScore
			// Node2 Score: (MaxNodeScore + MaxNodeScore) / 2 = MaxNodeScore

package main

// Run a slow C function saving a CPU profile.

/*
#include <stdint.h>

int salt1;
int salt2;

void cpuHog() {
	int foo = salt1;
	int i;

	for (i = 0; i < 100000; i++) {
		if (foo > 0) {
			foo *= foo;
		} else {
			foo *= foo + 1;
		}
	}
	salt2 = foo;
}

void cpuHog2() {
}

struct cgoTracebackArg {
	uintptr_t  context;
	uintptr_t  sigContext;

package main

/*
#include <stdint.h>
#include <stdlib.h>

int cpuHogCSalt1 = 0;
int cpuHogCSalt2 = 0;

void CPUHogCFunction0(int foo) {
	int i;
	for (i = 0; i < 100000; i++) {
		if (foo > 0) {
			foo *= foo;
		} else {
			foo *= foo + 1;
		}
		cpuHogCSalt2 = foo;
	}
}

void CPUHogCFunction() {
	CPUHogCFunction0(cpuHogCSalt1);
}

struct CgoTracebackArg {

	x = x + 1
	for x < len(b.s) {
		if b.s[x] != 0 {
			return uint(x)*wSize + T(b.s[x]), true
		}
		x = x + 1

	}
	return 0, false
}

func A() {
	s := N(100000)
	for i := 0; i < 1000; i += 30 {
		s.S(uint(i))
	}
	for j := 0; j < 1000; j++ {
		c := uint(0)
		for i, e := s.NS(0); e; i, e = s.NS(i + 1) {
			c++
		}
	}
}

func main() {
	time.Sleep(time.Second)
	A()

! stderr '(compile|gccgo)( |\.exe).*empty.go'

# Fuzzing indicates that one new interesting value was found with an empty
# corpus, and the total size of the cache is now 1.
go clean -fuzzcache
go test -fuzz=FuzzEmpty -fuzztime=10000x .
stdout 'new interesting: 1'
stdout 'total: 1'

# Fuzzing again with a small fuzztime does not find any other interesting
# values but still indicates that the cache size is 1.
go test -fuzz=FuzzEmpty -fuzztime=2x .