import org.gradle.internal.time.Timer;

@ServiceScope(Scope.Global.class)
public class DaemonRunningStats {

    private final long startTime = System.currentTimeMillis();
    private final Timer daemonTimer = Time.startTimer();
    private final Timer currentBuildTimer = Time.startTimer();

    private int buildCount;
    private long allBuildsTime;

    public int getBuildCount() {
        return buildCount;
    }

            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);

        return operation(
            operationContext -> {
                Timer timer = Time.startTimer();
                ImmutableSortedMap<String, FileSystemSnapshot> unfilteredOutputSnapshotsAfterExecution = outputSnapshotter.snapshotOutputs(work, context.getWorkspace());

    }

    @Override
    public boolean execute(@Nonnull CleanupProgressMonitor progressMonitor) {
        if (requiresCleanup()) {
            Timer timer = Time.startTimer();
            performCleanup(progressMonitor);
            LOGGER.debug("Processed version-specific caches at {} for cleanup in {}", versionSpecificCacheDirectoryScanner.getBaseDir(), timer.getElapsed());
            return true;

    private TransientConfigurationResults deserialize(Decoder decoder, ResolvedGraphResults graphResults, SelectedArtifactResults artifactResults, BuildOperationExecutor buildOperationProcessor) {
        Timer clock = Time.startTimer();
        Map<Long, DefaultResolvedDependency> allDependencies = new HashMap<>();
        Map<Dependency, DependencyGraphNodeResult> firstLevelDependencies = new LinkedHashMap<>();
        DependencyGraphNodeResult root;

package util

import (
	"time"
)

// startTime is a variable that represents the start time of the kubeadm process.
// It can be used to consistently use the same start time instead of calling time.Now()
// in multiple locations and ending up with minor time deviations.
var startTime time.Time

func init() {
	startTime = time.Now()
}

// StartTimeUTC returns startTime with its location set to UTC.

				return
			}
			opts.mode = traceviewer.ModeGoroutineOriented
			if g.StartTime != 0 {
				opts.startTime = g.StartTime.Sub(parsed.startTime())
			} else {
				opts.startTime = 0
			}
			if g.EndTime != 0 {
				opts.endTime = g.EndTime.Sub(parsed.startTime())
			} else { // The goroutine didn't end.
				opts.endTime = parsed.endTime().Sub(parsed.startTime())
			}
			opts.focusGoroutine = goid

    private final long startTime;
    private final boolean interactive;

    public DefaultBuildRequestMetaData(BuildClientMetaData clientMetaData, long startTime, boolean interactive) {
        this.clientMetaData = clientMetaData;
        this.startTime = startTime;
        this.interactive = interactive;
    }

    public DefaultBuildRequestMetaData(long startTime) {
        this(startTime, false);
    }

@UsedByScanPlugin
public class TestStartEvent {
    private final long startTime;
    private final Object parentId;

    @UsedByScanPlugin("test-distribution")
    public TestStartEvent(long startTime) {
        this(startTime, null);
    }

    @UsedByScanPlugin("test-distribution")
    public TestStartEvent(long startTime, Object parentId) {
        this.startTime = startTime;
        this.parentId = parentId;
    }