// if neither max_iters nor max_micros is set.
  static constexpr int64_t kDefaultMicros = 3000000;

  int64_t max_iters = 0;   // Maximum iterations to run, ignored if <= 0.
  int64_t max_micros = 0;  // Maximum microseconds to run, ignored if <= 0.
};

// Stats holds statistics collected during benchmarking.
struct Stats {
  std::vector<int64_t> per_iter_us;  // Per-iteration deltas in us.

        return fileEventFunctions.newWatcher(fileEvents)
            // TODO Figure out a good value for this
            .withLatency(20, TimeUnit.MICROSECONDS)
            .start();
    }

    @Override
    protected FileWatcherUpdater createFileWatcherUpdater(
        OsxFileWatcher watcher,
        FileWatcherProbeRegistry probeRegistry,

#### The time to answer helps the attackers

	{Ldate | Ltime | Lmicroseconds | Lshortfile, "XXX", "XXX" + Rdate + " " + Rtime + Rmicroseconds + " " + Rshortfile + " "},
	{Ldate | Ltime | Lmicroseconds | Llongfile | Lmsgprefix, "XXX", Rdate + " " + Rtime + Rmicroseconds + " " + Rlongfile + " XXX"},
	{Ldate | Ltime | Lmicroseconds | Lshortfile | Lmsgprefix, "XXX", Rdate + " " + Rtime + Rmicroseconds + " " + Rshortfile + " XXX"},
}

			Subsystem: subsystem,
			Name:      "transformation_duration_seconds",
			Help:      "Latencies in seconds of value transformation operations.",
			// In-process transformations (ex. AES CBC) complete on the order of 20 microseconds. However, when
			// external KMS is involved latencies may climb into hundreds of milliseconds.
			Buckets:        metrics.ExponentialBuckets(5e-6, 2, 25),
			StabilityLevel: metrics.ALPHA,
		},

                                        int64_t filesize);

// Returns "/tensorflow/core/checkpoint/sharding/callback_duration" cell which
// describes how long it took to execute the checkpoint sharding callback in
// microseconds.
monitoring::CounterCell& ShardingCallbackDuration();

// Returns "/tensorflow/core/checkpoint/sharding/num_checkpoint_shards_written"
// cell which describes how many checkpoint shard files were written during

	labels = append(labels, "api", "")
	lastIdx := len(labels) - 1
	for apiName, latency := range disk.Metrics.LastMinute {
		labels[lastIdx] = "storage." + apiName
		m.Set(driveAPILatencyMicros, float64(latency.Avg().Microseconds()),
			labels...)
	}
}

func (m *MetricValues) setDriveIOStatMetrics(ioStats driveIOStatMetrics, labels []string) {
	m.Set(driveReadsPerSec, ioStats.readsPerSec, labels...)

  return strdup(::tensorflow::io::GetTempFilename(extension).c_str());
}

TF_CAPI_EXPORT extern uint64_t TF_NowNanos(void) {
  return ::tensorflow::Env::Default()->NowNanos();
}

// Returns the number of microseconds since the Unix epoch.
TF_CAPI_EXPORT extern uint64_t TF_NowMicros(void) {
  return ::tensorflow::Env::Default()->NowMicros();
}

// Returns the number of seconds since the Unix epoch.

	systemstack(func() {
		futexsleep1(addr, val, ns)
	})
}

func futexsleep1(addr *uint32, val uint32, ns int64) {
	var timeout int32
	if ns >= 0 {
		// The timeout is specified in microseconds - ensure that we
		// do not end up dividing to zero, which would put us to sleep
		// indefinitely...
		timeout = timediv(ns, 1000, nil)
		if timeout == 0 {
			timeout = 1
		}
	}

TF_CAPI_EXPORT extern char* TF_GetTempFileName(const char* extension);

// Returns the number of nanoseconds since the Unix epoch.
TF_CAPI_EXPORT extern uint64_t TF_NowNanos(void);

// Returns the number of microseconds since the Unix epoch.
TF_CAPI_EXPORT extern uint64_t TF_NowMicros(void);

// Returns the number of seconds since the Unix epoch.
TF_CAPI_EXPORT extern uint64_t TF_NowSeconds(void);