}

    MonotonicClock(TimeSource timeSource, long syncIntervalMillis) {
        long nanoTime = timeSource.nanoTime();
        long currentTimeMillis = timeSource.currentTimeMillis();

        this.timeSource = timeSource;
        this.syncIntervalMillis = syncIntervalMillis;
        this.syncNanosRef = new AtomicLong(nanoTime);
        this.syncMillisRef = new AtomicLong(currentTimeMillis);

func archauxv(tag, val uintptr) {
	switch tag {
	case _AT_HWCAP:
		cpu.HWCap = uint(val)
	}
}

func osArchInit() {}

//go:nosplit
func cputicks() int64 {
	// nanotime() is a poor approximation of CPU ticks that is enough for the profiler.
	return nanotime()
}

const (
	_SS_DISABLE  = 2
	_NSIG        = 129
	_SIG_BLOCK   = 1
	_SIG_UNBLOCK = 2
	_SIG_SETMASK = 3
)

type sigset [2]uint64

        if (gradleVersion < SUPPORTS_BUILD_SERVICES) {
            return """
                def startAt = System.nanoTime()
                gradle.buildFinished {
                    long sinceStart = (System.nanoTime() - startAt) / 1000000L
                    if (sinceStart > 0 && sinceStart < $minimumBuildTimeMillis) {

    }

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

        // System.nanoTime() can go backwards under some circumstances.
        // http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6458294

// Trace time and clock.

package runtime

import (
	"internal/goarch"
	_ "unsafe"
)

// Timestamps in trace are produced through either nanotime or cputicks
// and divided by traceTimeDiv. nanotime is used everywhere except on
// platforms where osHasLowResClock is true, because the system clock
// isn't granular enough to get useful information out of a trace in
// many cases.
//

  ) {
    logEvent(ConnectionEvent.ConnectEnd(System.nanoTime(), connection, route, call))
  }

  override fun connectionClosed(connection: Connection) = logEvent(ConnectionEvent.ConnectionClosed(System.nanoTime(), connection))

  override fun connectionAcquired(
    connection: Connection,
    call: Call,
  ) {
    logEvent(ConnectionEvent.ConnectionAcquired(System.nanoTime(), connection, call))
  }

            def checkpoint1() {
                def startAt = System.nanoTime()
                while (System.nanoTime() - startAt < 1_000_000_000) {}
            }
            @groovy.transform.CompileStatic
            def checkpoint2() {
                def startAt = System.nanoTime()
                while (System.nanoTime() - startAt < 1_000_000_000) {}
            }
            @groovy.transform.CompileStatic

    public static final int SYNC_INTERVAL = 1000

    private TimeSource timeSource = Mock(TimeSource) {
        1 * currentTimeMillis() >> START_MILLIS
        1 * nanoTime() >> START_NANOS
    }

    private Clock clock = new MonotonicClock(timeSource, SYNC_INTERVAL)

    def "prevents time from going backwards"() {
        when:
        setNanos 0

        then:

   *
   * @since 10.0
   */
  public static Ticker systemTicker() {
    return SYSTEM_TICKER;
  }

  private static final Ticker SYSTEM_TICKER =
      new Ticker() {
        @Override
        @SuppressWarnings("GoodTime") // reading system time without TimeSource
        public long read() {
          return System.nanoTime();
        }
      };

 * (by default) uses {@link System#nanoTime}, it is unaffected by these changes.
 *
 * <p>Use this class instead of direct calls to {@link System#nanoTime} for two reasons:
 *
 * <ul>
 *   <li>The raw {@code long} values returned by {@code nanoTime} are meaningless and unsafe to use
 *       in any other way than how {@code Stopwatch} uses them.