Java Code Examples for org.openjdk.jmh.infra.Blackhole#consume()

@Benchmark
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(value = 1)
@Threads(50)
@Warmup(iterations = 5)
@Measurement(iterations = 5)
public void testSimpleBeanValidation(ValidationState state, Blackhole blackHole) {
    BenchmarkSetup benchmarkSetup = new BenchmarkSetup(BenchmarkModelWrapper::new, state);
    Result result = state.rule.executeOn(benchmarkSetup.model);
    assertThat(getActualViolationCount(result)).isEqualTo(benchmarkSetup.expectedViolationCount);
    blackHole.consume(result);
}
 

@Benchmark
@Fork(value = 1, warmups = 1)
@BenchmarkMode(Mode.Throughput)
@Warmup(iterations = 1)
public void init_with_wrapped_bouncy_keccak(Blackhole blackhole) {
    blackhole.consume(Function.parse("sam(bytes,bool,uint256[])", new WrappedKeccak(256)));
}
 

@Warmup(iterations = 1)
@Measurement(iterations = 10)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(value = 1)
@Threads(1)
@Benchmark
public void get(Blackhole blackhole, BenchmarkState state) {
    for (int i=0; i < state.bytes; ++i) {
        blackhole.consume(state.byteBuffer.get(i));
    }
}
 

/** Run a benchmark test on a function that produces a vector.
 * @param <V> Vector implementation type
 * @param input vector input
 * @param bh jmh blackhole for consuming output
 * @param fn function to call
 */
private static <V extends Vector<V>> void testUnary(final VectorInputBase<V> input, final Blackhole bh,
        final UnaryOperator<V> fn) {
    for (final V vec : input.getVectors()) {
        bh.consume(fn.apply(vec));
    }
}
 

@Benchmark
@BenchmarkMode(Mode.All)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public void testTheMethod5(TestState state, Blackhole blackhole) {
    SomeClass someClass = new SomeClass();
    blackhole.consume(someClass.oneMethod(state.m, state.s));
}
 

/** Run a benchmark test on a function that produces a double.
 * @param <V> Vector implementation type
 * @param input vector input
 * @param bh jmh blackhole for consuming output
 * @param fn function to call
 */
private static <V extends Vector<V>> void testToDouble(final VectorInputBase<V> input, final Blackhole bh,
        final ToDoubleFunction<V> fn) {
    for (final V vec : input.getVectors()) {
        bh.consume(fn.applyAsDouble(vec));
    }
}
 

@Override
void put(Blackhole bh) {
    IntObjectHashMap<Long> map = new IntObjectHashMap<Long>();
    for (int key : keys) {
        bh.consume(map.put(key, VALUE));
    }
}
 

@Setup
public void setup(final Blackhole bh) {
    workerBaseline = new Worker() {
        double x;

        @Override
        public void work() {
            // do nothing
        }
    };

    workerWrong = new Worker() {
        double x;

        @Override
        public void work() {
            Math.log(x);
        }
    };

    workerRight = new Worker() {
        double x;

        @Override
        public void work() {
            bh.consume(Math.log(x));
        }
    };

}
 

@Benchmark
public void test_account_3_short_circuit(Blackhole blackhole) {
    boolean valid = benchRule3.executeOn(sample).value();
    if (blackhole != null) {
        blackhole.consume(valid);
    }
}
 

@Benchmark
public void test_account_4_short_circuit(Blackhole blackhole) {
    boolean valid = benchRule4.executeOn(sample).value();
    if (blackhole != null) {
        blackhole.consume(valid);
    }
}
 

@Benchmark
@BenchmarkMode(Mode.Throughput)
@Warmup(iterations = 10, time = 3, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 50, time = 3, timeUnit = TimeUnit.SECONDS)
@Threads(1)
public void testSnappyDeCompress(Blackhole blackhole, MyState state) throws IOException {
    blackhole.consume(CompressionUtils.decompressAndBase64Decode(state.snappyCompressed, true, true));
}
 

@Benchmark
public void rawForLoop(Blackhole blackhole) {
  for (int i = 0; i < strings.size(); i++) {
    blackhole.consume(strings.get(i));
  }
}
 

@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void http2AddAllFastest(Blackhole bh) {
    bh.consume(emptyHttp2HeadersNoValidate.add(http2Headers));
}
 

@Benchmark
public void testAsyncPutItem(Blackhole blackhole) {
  String randomStr = RandomStringUtils.random(5);
  blackhole.consume(asyncClient.sets().putItem(KEY_SET_SYNC,randomStr));
}
 

@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void httpAddAllFastest(Blackhole bh) {
    bh.consume(emptyHttpHeadersNoValidate.add(httpHeaders));
}
 

public void valid_country_100(Blackhole blackhole) {
    boolean valid = ACCOUNT_VALID_COUNTRY_100.executeOn(MODEL).value();
    if (blackhole != null) {
        blackhole.consume(valid);
    }
}
 

@Benchmark
@BenchmarkMode(Mode.AverageTime)
public void httpAddAllFast(Blackhole bh) {
    bh.consume(emptyHttpHeaders.add(httpHeaders));
}
 

@Benchmark
public void withClock(Blackhole blackhole) throws InterruptedException {
  Instant start = clock.instant();
  Thread.sleep(2);
  blackhole.consume(Duration.between(start, clock.instant()).toMillis());
}
 

public static void runAndBlackhole(Runnable runnable, Blackhole blackhole) {
  runnable.run();
  blackhole.consume(runnable);
}
 

@Benchmark
public void hToG2(Blackhole bh) {
  ECP2 r = hashToG2(message);
  bh.consume(r);
}