this.timeSource = timeSource;
        reset();
    }

    @Override
    public String getElapsed() {
        long elapsedMillis = getElapsedMillis();
        return TimeFormatting.formatDurationVerbose(elapsedMillis);
    }

    @Override
    public long getElapsedMillis() {
        long elapsedNanos = timeSource.nanoTime() - startTime;
        long elapsedMillis = TimeUnit.NANOSECONDS.toMillis(elapsedNanos);

    }

    @Override
    public boolean hasExpired() {
        return getRemainingMillis() <= 0;
    }

    @Override
    public long getRemainingMillis() {
        return Math.max(timeoutMillis - getElapsedMillis(), 0);
    }

    @Override
    public long getTimeoutMillis() {
        return timeoutMillis;
    }

        try {
            workOutput = work.execute(executionRequest);
        } catch (Throwable t) {
            return Result.failed(t, Duration.ofMillis(timer.getElapsedMillis()));
        }

        Duration duration = Duration.ofMillis(timer.getElapsedMillis());
        ExecutionOutcome mode = determineOutcome(context, workOutput);

        return Result.success(duration, new ExecutionResultImpl(mode, workOutput));
    }

     */
    String getElapsed();

    /**
     * Return the elapsed time in ms. Returned value is always >= 0.
     * @return The elapsed time, in ms.
     */
    long getElapsedMillis();

    /**
     * Restart this timer. Sets elapsed time to zero.
     */
    void reset();

    public void buildStarted() {
        ++buildCount;
        currentBuildTimer.reset();
    }

    public void buildFinished() {
        long buildTime = Math.max(currentBuildTimer.getElapsedMillis(), 1);
        allBuildsTime += buildTime;
    }

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

        );
    }

    private OriginMetadata createOriginMetadata(CachingState.CacheKeyCalculatedState cacheKeyCalculatedState, Result result, Timer timer) {
        long snapshotOutputDuration = timer.getElapsedMillis();

        // The origin execution time is recorded as “work duration” + “output snapshotting duration”,
        // As this is _roughly_ the amount of time that is avoided by reusing the outputs,

                skipOutcome = ExecutionOutcome.SHORT_CIRCUITED;
            }
        }
        Duration duration = skipOutcome == ExecutionOutcome.SHORT_CIRCUITED ? Duration.ZERO : Duration.ofMillis(timer.getElapsedMillis());
        return CachingResult.shortcutResult(duration, Execution.skipped(skipOutcome, work), null, executionReason, null);
    }

    private double getIdleMinutes() {
        lock.lock();
        try {
            return idleTimer.getElapsedMillis() / 1000.0 / 60.0;
        } finally {
            lock.unlock();
        }
    }

    public long getIdleMillis() {
        if (state == State.Idle) {
            return idleTimer.getElapsedMillis();
        } else {
            return 0L;
        }
    }

                            }
                            if (fileLockContentionHandler.maybePingOwner(lockInfo.port, lockInfo.lockId, displayName, backoff.getTimer().getElapsedMillis() - lastPingTime, backoff.getSignal())) {
                                lastPingTime = backoff.getTimer().getElapsedMillis();