this.file = file;
        bufferedInputStream = new ResettableBufferedInputStream(new RandomAccessFileInputStream(file));
    }

    /**
     * Starts reading from the given offset.
     */
    public DataInputStream start(long offset) throws IOException {
        file.seek(offset);
        bufferedInputStream.clear();
        countingInputStream = new CountingInputStream(bufferedInputStream);

 * <p>
 * A server connector should only be used by one daemon, and has a single use lifecycle.
 * Implementations must be threadsafe so that start/stop can be called from different threads.
 */
public interface DaemonServerConnector extends Stoppable {

    /**
     * Starts accepting connections, passing any established connections to the given handler.
     * <p>

	traceEvGoCreateBlocked // goroutine creation (starts blocked) [timestamp, new goroutine ID, new stack ID, stack ID]

	// GoStatus with stack.
	traceEvGoStatusStack // goroutine status at the start of a generation, with a stack [timestamp, goroutine ID, M ID, status, stack ID]

	// Batch event for an experimental batch with a custom format.

	for k, v := range handlers {
		mux.HandleFunc(k, http.HandlerFunc(v))
	}

	// Start a local HTTP server
	server := httptest.NewUnstartedServer(mux)

	l, err := net.Listen("tcp", ":0")
	if err != nil {
		panic("Could not create listener for test: " + err.Error())
	}
	server.Listener = l
	server.Start()
	return server
}

go build -x -pgo=prof -o triv.exe triv.go
stderr 'preprofile.*-i.*prof'
stderr 'compile.*-pgoprofile=.*triv.go'

# check that PGO appears in build info
# N.B. we can't start the stdout check with -pgo because the script assumes that
# if the first arg starts with - it is a grep flag.
go version -m triv.exe
stdout 'build\s+-pgo=.*'${/}'prof'

# store the build ID
go list -export -json=BuildID -pgo=prof triv.go

type Instance interface {
	// Start this Server. Any components that were already added
	// will be run immediately. If any error is returned,
	// Start will terminate and return the error immediately.
	//
	// Once all startup components have been run, starts a polling
	// loop to continue monitoring for new components and returns nil.
	Start(stop <-chan struct{}) error

	activeConnectionsURL := fmt.Sprintf("http://%s/stats?usedonly&filter=downstream_cx_active$", adminHost)
	stats, err := http.DoHTTPGetWithTimeout(activeConnectionsURL, 2*time.Second)
	if err != nil {
		return -1, fmt.Errorf("unable to get listener stats from Envoy : %v", err)
	}
	if stats.Len() == 0 {
		return -1, nil
	}
	activeConnections := 0
	for stats.Len() > 0 {
		line, _ := stats.ReadString('\n')

 */

package org.gradle.process.internal.worker;

import org.gradle.process.ExecResult;

public interface WorkerControl {
    /**
     * Starts the worker process, blocking until successfully started.
     */
    WorkerProcess start();

    /**
     * Requests that the worker complete all work and stop. Blocks until the worker process has stopped.
     */
    ExecResult stop();

    /**

)

// Manager manages all the DRA resource plugins running on a node.
type Manager interface {
	// Start starts the reconcile loop of the manager.
	// This will ensure that all claims are unprepared even if pods get deleted unexpectedly.
	Start(activePods ActivePodsFunc, sourcesReady config.SourcesReady) error

	// PrepareResources prepares resources for a pod.

 */
public interface DeploymentHandle {
    /**
     * Returns true if the deployment is still running.
     */
    boolean isRunning();

    /**
     * Starts the given deployment.
     * @param deployment the deployment to be started
     */
    void start(Deployment deployment);

    /**
     * Stops the deployment.
     */
    void stop();