}
  }

  private static void assertNotInterrupted() {
    assertFalse(Thread.interrupted());
  }

  private static void requestInterruptIn(long millis) {
    InterruptionUtil.requestInterruptIn(millis, MILLISECONDS);
  }

  @CanIgnoreReturnValue
  private static Thread acquireFor(final Lock lock, final long duration, final TimeUnit unit) {

            if (currentIteration > scenarioDefinition.getWarmUpCount()) {
                MeasuredOperation measuredOperation = new MeasuredOperation();
                measuredOperation.setTotalTime(Duration.millis(invocationResult.getExecutionTime().toMillis()));
                results.add(measuredOperation);
            }
            scenarioReporter.accept(invocationResult);
        };
    }

        private int waiting;

        @SuppressWarnings("WaitNotInLoop")
        @Override
        public boolean await(long millis) throws InterruptedException {
            lock.lock();
            try {
                waiting++;
                return condition.await(millis, MILLISECONDS);
            } finally {
                waiting--;
                lock.unlock();
            }
        }

            builder.allRecordCount(searchHits.getTotalHits().value);
            builder.allRecordCountRelation(searchHits.getTotalHits().relation.toString());
            builder.queryTime(searchResponse.getTook().millis());

            if (searchResponse.getTotalShards() != searchResponse.getSuccessfulShards()) {
                builder.partialResults(true);
            }

            // build highlighting fields

                                MeasuredOperation operation = new MeasuredOperation();
                                operation.setTotalTime(Duration.millis(resultSet.getBigDecimal(6)));
                                performanceResults.buildResult(displayInfo).add(operation);
                                builds.add(displayInfo);
                            }

        System.nanoTime() / 1000000L
    }

    static long toMillis(double seconds) {
        return (long) (seconds * 1000)
    }

    void setShortTimeout(int millis) {
        this.timeout = millis
    }

    ExecutorFactory getExecutorFactory() {
        return new ExecutorFactory() {
            @Override
            ManagedExecutor create(String displayName) {

    }

    override fun cancel() {
      canceled = true
      sourcePipe.cancel()
      sinkPipe.cancel()
    }
  }

  companion object {
    private fun ns(millis: Long): Long {
      return millis * 1000000L
    }
  }

 * quantiles. All algorithms modify the dataset they are given (the cost of a copy to avoid this
 * will be constant across algorithms).
 *
 * @author Pete Gillin
 * @since 20.0
 */
enum QuantilesAlgorithm {

  /**
   * Sorts the dataset, and picks values from it. When computing multiple quantiles, we sort once
   * and pick multiple values.
   */
  SORTING {

          "interval": "1m",
          "intervalFactor": 2,
          "legendFormat": "{{server,endpoint}}",
          "refId": "A"
        }
      ],
      "title": "Avg. Link Latency (millis)",
      "type": "timeseries"
    },
    {
      "datasource": {
        "type": "prometheus",
        "uid": "${DS_PROMETHEUS}"
      },
      "fieldConfig": {
        "defaults": {

    final List<String> events = Lists.newArrayList();

    @Override
    public long readMicros() {
      return NANOSECONDS.toMicros(instant);
    }

    void sleepMillis(int millis) {
      sleepMicros("U", MILLISECONDS.toMicros(millis));
    }

    void sleepMicros(String caption, long micros) {
      instant += MICROSECONDS.toNanos(micros);