Java 类org.openjdk.jmh.annotations.OutputTimeUnit 实例源码

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(1)
@OperationsPerInvocation(10000)
public void testApi() {
  Map<String, Object> data = new HashMap<String, Object>();
  data.put("encryptKey", "0000000000000000");
  data.put("barcode", "LH10312ACCF23C4F3A5");

  Multimap<String, Rule> rules = ArrayListMultimap.create();

  rules.put("barcode", Rule.required());
  rules.put("barcode", Rule.regex("[0-9A-F]{16}"));
  rules.put("encryptKey", Rule.required());
  rules.put("encryptKey", Rule.regex("LH[0-7][0-9a-fA-F]{2}[0-5][0-4][0-9a-fA-F]{12}"));
  try {
    Validations.validate(data, rules);
  } catch (Exception e) {
  }

}

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Fork(1)
@OperationsPerInvocation(10000)
public void testAverage() {
  Map<String, Object> data = new HashMap<String, Object>();
  data.put("encryptKey", "0000000000000000");
  data.put("barcode", "LH10312ACCF23C4F3A5");

  Multimap<String, Rule> rules = ArrayListMultimap.create();

  rules.put("barcode", Rule.required());
  rules.put("barcode", Rule.regex("[0-9A-F]{16}"));
  rules.put("encryptKey", Rule.required());
  rules.put("encryptKey", Rule.regex("LH[0-7][0-9a-fA-F]{2}[0-5][0-4][0-9a-fA-F]{12}"));
  try {
    Validations.validate(data, rules);
  } catch (Exception e) {
  }
}

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void latency() throws InvalidObjectException {
    ClientOrderBuilder order = new ClientOrderBuilder();
    order.setClientId(1234);
    order.setAssignee("ALGO");
    order.setBoardCode("MAIN");
    order.setCurrencyCode("HKD");
    order.setQuantity(1000);
    order.setId(123456789);
    order.setPrice(3.0);
    order.setCreatedBy("CREATEDBY");
    order.setUpdatedBy("UPDATEDBY");
    order.setExchangeCode("1234");
    order.setFixOrder(true);
    order.setCreatedTime(System.currentTimeMillis());
    order.setOrderStatus((byte) 'a');
    order.setSide((byte) '1');

    order.apply();
    orders[(index++) % orders.length] = order;
}

@Benchmark
@BenchmarkMode({   Mode.Throughput})
  @OutputTimeUnit
    (TimeUnit.MILLISECONDS)
public long testUnfairLockContended(Contended contended )
{
    contended.unfairLock.lock();
    try{
        return execute();
    }
    finally
    {
        contended.unfairLock.unlock();
    }



}

@Benchmark
@BenchmarkMode({   Mode.Throughput})
  @OutputTimeUnit
    (TimeUnit.MILLISECONDS)
public long testFairLockContended(Contended contended)
{
    contended.fairLock.lock();
    try{
        return execute();
    }
    finally
    {
        contended.fairLock.unlock();
    }



}

@Benchmark
@BenchmarkMode({Mode.Throughput, Mode.AverageTime, Mode.SampleTime, Mode.SingleShotTime})
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Warmup(iterations = 5, time = 100, timeUnit = TimeUnit.MICROSECONDS)
@Measurement(iterations = ITERATIONS_COUNT, time = 1000, timeUnit = TimeUnit.MICROSECONDS)
@Fork(1)
public Message timeMergeAndBuild() {
  dummy = ++dummy % Integer.MAX_VALUE;

  Builder builder = newBuilder(expectedMessage)
      .getFieldBuilder(galaxyStar, 0)
          .setField(starName, String.valueOf(dummy))
          .mergeFrom(mergeStar1Message)
          .getFieldBuilder(starPlanet, 0)
              .mergeFrom(mergePlanet1Message)
              .toParent()
          .toParent();

  return builder.build();
}

@Benchmark
@BenchmarkMode({Mode.Throughput, Mode.AverageTime, Mode.SampleTime, Mode.SingleShotTime})
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Warmup(iterations = 5, time = 100, timeUnit = TimeUnit.MICROSECONDS)
@Measurement(iterations = ITERATIONS_COUNT, time = 1000, timeUnit = TimeUnit.MICROSECONDS)
@Fork(1)
public Galaxy timeMergeAndBuildOriginalGM() {
  dummy = ++dummy % Integer.MAX_VALUE;

  Galaxy.Builder builder = Galaxy.newBuilder((Galaxy) expectedMessage);
  builder.getStarBuilder(0)
      .setName(String.valueOf(dummy))
      .mergeFrom(mergeStar1Message)
      .getPlanetBuilder(0)
      .mergeFrom(mergePlanet1Message);

  return builder.build();    
}

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public int stringDictionary() {
  int length = _stringDictionary.length();
  int ret = 0;
  int[] dictIds = new int[NUM_ROUNDS];
  for (int i = 0; i < NUM_ROUNDS; i++) {
    int dictId = RANDOM.nextInt(length);
    String value = _stringDictionary.getStringValue(dictId);
    ret += _stringDictionary.indexOf(value);
    dictIds[i] = dictId;
  }
  String[] outValues = new String[NUM_ROUNDS];
  _stringDictionary.readStringValues(dictIds, 0, NUM_ROUNDS, outValues, 0);
  for (int i = 0; i < NUM_ROUNDS; i++) {
    ret += outValues[0].length();
  }
  return ret;
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(value = 1)
@Threads(1)
@Warmup(iterations = 5)
@Measurement(iterations = 20)
public void testCascadedValidation(ParsingBeansSpeedState state, Blackhole bh) {
    // Validator in new factory

    for ( Object o : state.holder.beans ) {
        bh.consume( state.validator.getConstraintsForClass( o.getClass() ).isBeanConstrained() );
    }
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@Fork(value = 1)
@Threads(50)
@Warmup(iterations = 20) // it seems that as there are a lot of beans it takes some time to warmup
@Measurement(iterations = 30)
public void testCascadedValidation(RawValidationSpeedState state, Blackhole bh) {
    for ( Object o : state.holder.beans ) {
        Set<ConstraintViolation<Object>> constraintViolations = state.validator.validate( o );
        bh.consume( constraintViolations );
    }
}

@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public int testFieldAccessReflectionApi(FieldAccessReflectionApiState state)
        throws IllegalArgumentException, IllegalAccessException {
    return state.intValField.getInt(state.foo);
}

@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Benchmark
public int testPropertyAccessReflectionApi(PropertyAccessReflectionApiState state)
        throws IllegalAccessException, InvocationTargetException {
    return (int)state.intValAccessorMethod.invoke(state.foo);
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public List<String> testSingleSearch(Data data, Iterator i) {
    String query = null;
    while(query == null) {
        query = i.getNextQuery(data.queries);
    }
    return data.wordSearch.findSimilarWords(query);
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientSummaryThroughput() {
  promSummary = io.prometheus.client.Summary.build().name("name").help("help").create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promSummary.observe(i);
  }
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientSummaryThroughputWithLabels() {
  promSummary = io.prometheus.client.Summary.build().name("name").help("help").labelNames(LABEL_NAMES).create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promSummary.labels(LABEL_VALUES.get(i % LABEL_VALUES.size())).observe(i);
  }
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSummaryThroughput() {
  summary = new SummaryBuilder("name", "help").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    summary.observe(i);
  }
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSummaryThroughputWithLabels() {
  summary = new SummaryBuilder("name", "help").withReservoir().withUniformReservoir(1000).withLabels("label1", "label2").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    summary.observe(i, LABEL_VALUES.get(i % LABEL_VALUES.size()));
  }
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientGaugeLatency() {
  promGauge = io.prometheus.client.Gauge.build().name("name").help("help").create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promGauge.inc();
  }
  actualIterations = promGauge.labels().get();
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientGaugeLatencyWithLabels() {
  promGauge = io.prometheus.client.Gauge.build().name("name").help("help").labelNames(LABEL_NAMES).create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promGauge.labels(LABEL_VALUES).inc();
  }
  actualIterations = promGauge.labels(LABEL_VALUES).get();
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSettableGaugeLatency() {
  gauge = new SettableGaugeBuilder("name", "help").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    gauge.set(i);
  }
  actualIterations = gauge.getValue() + 1;
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSettableGaugeLatencyWithLabels() {
  gauge = new SettableGaugeBuilder("name", "help").withLabels("label1", "label2").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    gauge.set(i, LABEL_VALUES);
  }
  actualIterations = gauge.getValue(LABEL_VALUES) + 1;
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientGaugeLatency() {
  promHistogram = io.prometheus.client.Histogram.build().name("name").help("help").create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promHistogram.observe(i);
  }
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientGaugeLatencyWithLabels() {
  promHistogram = io.prometheus.client.Histogram.build().name("name").help("help").labelNames(LABEL_NAMES).create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promHistogram.labels(LABEL_VALUES).observe(i);
  }
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSettableGaugeLatency() {
  histogram = new HistogramBuilder("name", "help").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    histogram.observe(i);
  }
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSettableGaugeLatencyWithLabels() {
  histogram = new HistogramBuilder("name", "help").withLabels("label1", "label2").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    histogram.observe(i, LABEL_VALUES);
  }
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientGaugeThroughput() {
  promGauge = io.prometheus.client.Gauge.build().name("name").help("help").create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promGauge.inc();
  }
  actualIterations = promGauge.labels().get();
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientGaugeThroughputWithLabels() {
  promGauge = io.prometheus.client.Gauge.build().name("name").help("help").labelNames(LABEL_NAMES).create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promGauge.labels(LABEL_VALUES.get(i % LABEL_VALUES.size())).inc();
  }
  actualIterations = LABEL_VALUES.stream().mapToDouble(labelValues -> promGauge.labels(labelValues).get()).sum();
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSettableGaugeThroughput() {
  gauge = new SettableGaugeBuilder("name", "help").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    gauge.set(i);
  }
  actualIterations = gauge.getValue() + 1;
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSettableGaugeThroughputWithLabels() {
  gauge = new SettableGaugeBuilder("name", "help").withLabels("label1", "label2").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    gauge.set(i, LABEL_VALUES.get(i % LABEL_VALUES.size()));
  }
  actualIterations = LABEL_VALUES.stream()
    .mapToDouble(labelValues -> gauge.getValue(labelValues))
    .max()
    .orElseThrow(() -> new RuntimeException("Error")) + 1;
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientSummaryLatency() {
  promSummary = io.prometheus.client.Summary.build().name("name").help("help").create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promSummary.observe(i);
  }
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientSummaryLatencyWithLabels() {
  promSummary = io.prometheus.client.Summary.build().name("name").help("help").labelNames(LABEL_NAMES).create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    promSummary.labels(LABEL_VALUES).observe(i);
  }
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSettableSummaryLatency() {
  summary = new SummaryBuilder("name", "help").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    summary.observe(i);
  }
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSettableSummaryLatencyWithLabels() {
  summary = new SummaryBuilder("name", "help").withLabels("label1", "label2").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    summary.observe(i, LABEL_VALUES);
  }
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientCounterLatency() {
  prometheusCounter = io.prometheus.client.Counter.build().name("name").help("help").create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    prometheusCounter.inc();
  }
  actualIterations = prometheusCounter.labels().get();
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientCounterLatencyWithLabels() {
  prometheusCounter = io.prometheus.client.Counter.build().name("name").help("help").labelNames(LABEL_NAMES).create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    prometheusCounter.labels(LABEL_VALUES).inc();
  }
  actualIterations = prometheusCounter.labels(LABEL_VALUES).get();
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureCounterLatency() {
  counter = new CounterBuilder("name", "help").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    counter.inc();
  }
  actualIterations = counter.getValue();
}

@Benchmark
@BenchmarkMode(Mode.SampleTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureCounterLatencyWithLabels() {
  counter = new CounterBuilder("name", "help").withLabels("label1", "label2").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    counter.inc(LABEL_VALUES);
  }
  actualIterations = counter.getValue(LABEL_VALUES);
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientCounterThroughput() {
  prometheusCounter = io.prometheus.client.Counter.build().name("name").help("help").create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    prometheusCounter.inc();
  }
  actualIterations = prometheusCounter.labels().get();
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureSimpleClientCounterThroughputWithLabels() {
  prometheusCounter = io.prometheus.client.Counter.build().name("name").help("help").labelNames(LABEL_NAMES).create();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    prometheusCounter.labels(LABEL_VALUES.get(i % LABEL_VALUES.size())).inc();
  }
  actualIterations = LABEL_VALUES.stream().mapToDouble(labelValues -> prometheusCounter.labels(labelValues).get()).sum();
}

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public void measureCounterThroughput() {
  counter = new CounterBuilder("name", "help").build();
  for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
    counter.inc();
  }
  actualIterations = counter.getValue();
}