// Check if first block is valid.
	if !utf8.Valid(next) {
		return errInvalidTextEncodingError()
	}

	// Create queue
	r.queue = make(chan *queueItem, runtime.GOMAXPROCS(0))
	r.input = make(chan *queueItem, runtime.GOMAXPROCS(0))
	r.readerWg.Add(1)

	// Start splitter
	go func() {
		defer close(r.input)
		defer close(r.queue)
		defer r.readerWg.Done()
		for {
			q := queueItem{

// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"runtime"
	"sync/atomic"
	"time"
)

var a uint64 = 0

func main() {
	runtime.GOMAXPROCS(2) // With just 1, infinite loop never yields

	go func() {
		for {
			atomic.AddUint64(&a, uint64(1))
		}
	}()

	time.Sleep(10 * time.Millisecond) // Short sleep is enough in passing case

	*s = 1
	HammerSemaphore(s, b.N, make(chan bool, 2))
}

func BenchmarkContendedSemaphore(b *testing.B) {
	b.StopTimer()
	s := new(uint32)
	*s = 1
	c := make(chan bool)
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
	b.StartTimer()

	go HammerSemaphore(s, b.N/2, c)
	go HammerSemaphore(s, b.N/2, c)
	<-c
	<-c
}

func HammerMutex(m *Mutex, loops int, cdone chan bool) {
	for i := 0; i < loops; i++ {

		for i := 0; i < 10; i++ {
			buf := &bytes.Buffer{}
			pprof.Lookup("goroutine").WriteTo(buf, 2)
		}
		wg.Done()
	}

	go test()
	go test()
	wg.Wait()
}

func main() {
	runtime.GOMAXPROCS(4)
	for i := 0; i < 10; i++ {
		test()
	}

package runtime_test

import (
	"internal/testenv"
	"math"
	"runtime"
	"sync"
	"sync/atomic"
	"testing"
	"time"
)

func TestChan(t *testing.T) {
	defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
	N := 200
	if testing.Short() {
		N = 20
	}
	for chanCap := 0; chanCap < N; chanCap++ {
		{
			// Ensure that receive from empty chan blocks.
			c := make(chan int, chanCap)
			recv1 := false

package main

import "C"

import (
	"os"
	"runtime"
	"sync/atomic"
)

var started int32

// Start a goroutine that loops forever.
func init() {
	runtime.GOMAXPROCS(1)
	go func() {
		for {
			atomic.StoreInt32(&started, 1)
		}
	}()
}

//export GoFunction8
func GoFunction8() {
	for atomic.LoadInt32(&started) == 0 {
		runtime.Gosched()
	}
	os.Exit(0)
}

	"github.com/klauspost/compress/s2"
	"github.com/klauspost/compress/zstd"
	gzip "github.com/klauspost/pgzip"
	"github.com/pierrec/lz4"
)

// Max bzip2 concurrency across calls. 50% of GOMAXPROCS.
var bz2Limiter = pbzip2.CreateConcurrencyPool((runtime.GOMAXPROCS(0) + 1) / 2)

func detect(r *bufio.Reader) format {
	z, err := r.Peek(4)
	if err != nil {
		return formatUnknown
	}
	for _, f := range magicHeaders {

	EvStack             = 3  // stack [stack id, number of PCs, array of {PC, func string ID, file string ID, line}]
	EvGomaxprocs        = 4  // current value of GOMAXPROCS [timestamp, GOMAXPROCS, stack id]
	EvProcStart         = 5  // start of P [timestamp, thread id]
	EvProcStop          = 6  // stop of P [timestamp]
	EvGCStart           = 7  // GC start [timestamp, seq, stack id]

			Alloc:      memstats.Alloc,
			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,

package main

import (
	"fmt"
	"os"
	"runtime"
)

func init() {
	register("CrashDumpsAllThreads", CrashDumpsAllThreads)
}

func CrashDumpsAllThreads() {
	const count = 4
	runtime.GOMAXPROCS(count + 1)

	chans := make([]chan bool, count)
	for i := range chans {
		chans[i] = make(chan bool)
		go crashDumpsAllThreadsLoop(i, chans[i])
	}

	// Wait for all the goroutines to start executing.