mux.Handle("/jsontrace", JSONTraceHandler(parsed))
	mux.Handle("/static/", traceviewer.StaticHandler())

	// Goroutines handlers.
	mux.HandleFunc("/goroutines", GoroutinesHandlerFunc(parsed.summary.Goroutines))
	mux.HandleFunc("/goroutine", GoroutineHandler(parsed.summary.Goroutines))

	// MMU handler.
	mux.HandleFunc("/mmu", traceviewer.MMUHandlerFunc(ranges, mutatorUtil))

	// Basic pprof endpoints.

	}
	unlock(&netpollBrokenLock)
}

// Polls for ready network connections.
// Returns list of goroutines that become runnable.
func netpoll(delay int64) (gList, int32) {
	// Implementation for platforms that do not support
	// integrated network poller.
	if delay != 0 {
		// This lock ensures that only one goroutine tries to use
		// the note. It should normally be completely uncontended.
		lock(&netpollStubLock)

package cfg

import (
	"cmd/go/internal/par"
	"os/exec"
)

var lookPathCache par.ErrCache[string, string]

// LookPath wraps exec.LookPath and caches the result
// which can be called by multiple Goroutines at the same time.
func LookPath(file string) (path string, err error) {
	return lookPathCache.Do(file,
		func() (string, error) {
			return exec.LookPath(file)
		})

              rate(
                go_memstats_mallocs_total{%(appLabels)s}
              [$__rate_interval])
            )
          |||
        ),
      ],

      goroutines:
        self.query(
          'Goroutines ({{pod}})',
          |||
            sum by (pod) (
              go_goroutines{%(appLabels)s}
            )
          |||
        ),

      connections:
        [

// The WriteCloser's Close method must be used to flush pending data to w.
// The Compressor itself must be safe to invoke from multiple goroutines
// simultaneously, but each returned writer will be used only by
// one goroutine at a time.
type Compressor func(w io.Writer) (io.WriteCloser, error)

// A Decompressor returns a new decompressing reader, reading from r.

//
// Some goroutines (the finalizer goroutine, which at various times can be
// either a "system" or a "user" goroutine, and the goroutine that is
// coordinating the profile, any goroutines created during the profile) move
// directly to the "Satisfied" state.
type goroutineProfileState uint32

const (
	goroutineProfileAbsent goroutineProfileState = iota
	goroutineProfileInProgress

// limitations under the License.

package envoyfilter

import (
	"testing"

	"istio.io/istio/tests/util/leak"
)

func TestMain(m *testing.M) {
	// CheckMain asserts that no goroutines are leaked after a test package exits.
	leak.CheckMain(m)

// limitations under the License.

package server

import (
	"testing"

	"istio.io/istio/tests/util/leak"
)

func TestMain(m *testing.M) {
	// CheckMain asserts that no goroutines are leaked after a test package exits.
	leak.CheckMain(m)

// In addition, it has a data race because the loop updates v
// concurrent with the goroutines accessing it.
//
//	for _, v := range elem {
//	    go func() {
//	        use(v)  // incorrect, and a data race
//	    }()
//	}
//
// A fix is the same as before. The checker also reports problems
// in goroutines started by golang.org/x/sync/errgroup.Group.
// A hard-to-spot variant of this form is common in parallel tests:

// limitations under the License.

package route

import (
	"testing"

	"istio.io/istio/tests/util/leak"
)

func TestMain(m *testing.M) {
	// CheckMain asserts that no goroutines are leaked after a test package exits.
	leak.CheckMain(m)