b.StopTimer()

	path := newTempFile(b)
	defer removeSilent(path)

	m := mesh.DefaultMeshConfig()
	writeMessage(b, path, m)

	w := newWatcher(b, path, false)

	b.StartTimer()

	handler := func(mc *meshconfig.MeshConfig) {
		// Do nothing
	}

	for i := 0; i < b.N; i++ {
		handler(w.Mesh())
	}

        GradleInternal gradle,
        SettingsLocation settingsLocation,
        ClassLoaderScope baseClassLoaderScope,
        StartParameter startParameter
    ) {
        Timer settingsProcessingClock = Time.startTimer();
        TextResourceScriptSource settingsScript = new TextResourceScriptSource(textFileResourceLoader.loadFile("settings file", settingsLocation.getSettingsFile()));

	b.ReportAllocs()
	c := testConfig(b)
	fun := c.Fun("entry", bg(size)...)
	CheckFunc(fun.f)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		fn(fun.f)
		b.StopTimer()
		CheckFunc(fun.f)
		b.StartTimer()
	}
}

// benchFnBlock runs passFunc across a function with b.N blocks.
func benchFnBlock(b *testing.B, fn passFunc, bg blockGen) {
	b.ReportAllocs()
	c := testConfig(b)
	fun := c.Fun("entry", bg(b.N)...)

	assert.Empty(b, err)

	for i := 0; i < b.N; i++ {
		pids := getPids(re)

		b.StopTimer()
		assert.NotZero(b, pids)
		assert.Contains(b, pids, os.Getpid())
		b.StartTimer()
	}

    }

    public WorkerDaemonClient startDaemon(DaemonForkOptions forkOptions) {
        LOG.debug("Starting Gradle worker daemon with fork options {}.", forkOptions);
        Timer clock = Time.startTimer();
        MultiRequestWorkerProcessBuilder<TransportableActionExecutionSpec, DefaultWorkResult> builder = workerDaemonProcessFactory.multiRequestWorker(WorkerDaemonServer.class);
        builder.setBaseName("Gradle Worker Daemon");

            .map(PreviousExecutionState::getOutputFilesProducedByWork)
            .orElse(ImmutableSortedMap.of());

        ExecutionOutcome skipOutcome;
        Timer timer = Time.startTimer();
        String executionReason = null;
        if (outputFilesAfterPreviousExecution.isEmpty()) {
            LOGGER.info("Skipping {} as it has no source files and no previous output files.", work.getDisplayName());

			buf1 := getInputBuf(buf, n)
			runtime.GC()
			b.StartTimer()
			for i := 0; i < b.N; i++ {
				io.Copy(io.Discard, NewReader(bytes.NewReader(buf1), LSB, 8))
			}
		})
		b.Run(fmt.Sprint("1e-Reuse", e), func(b *testing.B) {
			b.StopTimer()
			b.SetBytes(int64(n))
			buf1 := getInputBuf(buf, n)
			runtime.GC()
			b.StartTimer()
			r := NewReader(bytes.NewReader(buf1), LSB, 8)

            T out = cache.getIfPresent(id);
            if (out != null) {
                stats.readFromCache();
                return out;
            }
            Timer timer = Time.startTimer();
            T value = createIfNotPresent.get();
            stats.readFromDisk(timer.getElapsedMillis());
            cache.put(id, value);
            return value;
        }
    }

            @Override
            public void run(BuildOperationContext context) {
                DefaultCleanupProgressMonitor progressMonitor = new DefaultCleanupProgressMonitor(context);
                Timer timer = Time.startTimer();
                try {
                    cacheCleanupStrategy.getCleanupAction().clean(cleanableStore, progressMonitor);
                    FileUtils.touch(gcFile);

        this.buildOperationRunner = buildOperationRunner;
        this.buildOperationExecutor = buildOperationExecutor;
    }

    public void generate() {
        Timer clock = Time.startTimer();

        buildOperationRunner.run(new RunnableBuildOperation() {
            @Override
            public void run(BuildOperationContext context) {