< prev index next >
test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/IntScalar.java
Print this page
rev 55606 : 8221812: Fine-tune jmh test for vector api
Summary: To compare performance of vector api and auto vectorization, vector
api and scalar test cases are updated to keep aligned.
Reviewed-by: duke
@@ -1,7 +1,7 @@
/*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
@@ -25,18 +25,21 @@
import java.util.concurrent.TimeUnit;
import java.util.function.IntFunction;
import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
@Warmup(iterations = 3, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(value = 1, jvmArgsPrepend = {"--add-modules=jdk.incubator.vector"})
public class IntScalar extends AbstractVectorBenchmark {
+ static final int INVOC_COUNT = 1; // To align with vector benchmarks.
+
@Param("1024")
int size;
int[] fill(IntFunction<Integer> f) {
int[] array = new int[size];
@@ -70,446 +73,494 @@
final IntFunction<boolean[]> fmr = vl -> rms;
final IntFunction<int[]> fs = vl -> ss;
@Benchmark
- public Object add() {
+ public void add(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)(a + b);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object addMasked() {
+ public void addMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
if (ms[i % ms.length]) {
rs[i] = (int)(a + b);
} else {
rs[i] = a;
}
}
- return rs;
+ }
+ bh.consume(rs);
}
@Benchmark
- public Object sub() {
+ public void sub(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)(a - b);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object subMasked() {
+ public void subMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
if (ms[i % ms.length]) {
rs[i] = (int)(a - b);
} else {
rs[i] = a;
}
}
- return rs;
+ }
+ bh.consume(rs);
}
@Benchmark
- public Object mul() {
+ public void mul(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)(a * b);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object mulMasked() {
+ public void mulMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
if (ms[i % ms.length]) {
rs[i] = (int)(a * b);
} else {
rs[i] = a;
}
}
- return rs;
+ }
+ bh.consume(rs);
}
@Benchmark
- public Object and() {
+ public void and(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)(a & b);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object andMasked() {
+ public void andMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
if (ms[i % ms.length]) {
rs[i] = (int)(a & b);
} else {
rs[i] = a;
}
}
- return rs;
+ }
+ bh.consume(rs);
}
@Benchmark
- public Object or() {
+ public void or(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)(a | b);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object orMasked() {
+ public void orMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
if (ms[i % ms.length]) {
rs[i] = (int)(a | b);
} else {
rs[i] = a;
}
}
- return rs;
+ }
+ bh.consume(rs);
}
@Benchmark
- public Object xor() {
+ public void xor(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)(a ^ b);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object xorMasked() {
+ public void xorMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
if (ms[i % ms.length]) {
rs[i] = (int)(a ^ b);
} else {
rs[i] = a;
}
}
- return rs;
+ }
+ bh.consume(rs);
}
@Benchmark
- public Object shiftR() {
+ public void shiftR(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)((a >>> b));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object shiftRMasked() {
+ public void shiftRMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
if (ms[i % ms.length]) {
rs[i] = (int)((a >>> b));
} else {
rs[i] = a;
}
}
- return rs;
+ }
+ bh.consume(rs);
}
@Benchmark
- public Object shiftL() {
+ public void shiftL(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)((a << b));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object shiftLMasked() {
+ public void shiftLMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
if (ms[i % ms.length]) {
rs[i] = (int)((a << b));
} else {
rs[i] = a;
}
}
- return rs;
+ }
+ bh.consume(rs);
}
@Benchmark
- public Object aShiftR() {
+ public void aShiftR(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)((a >> b));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object aShiftRMasked() {
+ public void aShiftRMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
if (ms[i % ms.length]) {
rs[i] = (int)((a >> b));
} else {
rs[i] = a;
}
}
- return rs;
+ }
+ bh.consume(rs);
}
@Benchmark
- public Object aShiftRShift() {
+ public void aShiftRShift(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)((a >> b));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object aShiftRMaskedShift() {
+ public void aShiftRMaskedShift(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
boolean m = ms[i % ms.length];
rs[i] = (m ? (int)((a >> b)) : a);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object shiftRShift() {
+ public void shiftRShift(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)((a >>> b));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object shiftRMaskedShift() {
+ public void shiftRMaskedShift(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
boolean m = ms[i % ms.length];
rs[i] = (m ? (int)((a >>> b)) : a);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object shiftLShift() {
+ public void shiftLShift(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)((a << b));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object shiftLMaskedShift() {
+ public void shiftLMaskedShift(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
boolean m = ms[i % ms.length];
rs[i] = (m ? (int)((a << b)) : a);
}
+ }
- return rs;
+ bh.consume(rs);
}
@@ -522,277 +573,330 @@
@Benchmark
- public Object max() {
+ public void max(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)(Math.max(a, b));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object min() {
+ public void min(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
rs[i] = (int)(Math.min(a, b));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public int andAll() {
+ public void andAll(Blackhole bh) {
int[] as = fa.apply(size);
int r = -1;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = -1;
for (int i = 0; i < as.length; i++) {
r &= as[i];
}
- return r;
+ }
+ bh.consume(r);
}
@Benchmark
- public int orAll() {
+ public void orAll(Blackhole bh) {
int[] as = fa.apply(size);
int r = 0;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = 0;
for (int i = 0; i < as.length; i++) {
r |= as[i];
}
- return r;
+ }
+ bh.consume(r);
}
@Benchmark
- public int xorAll() {
+ public void xorAll(Blackhole bh) {
int[] as = fa.apply(size);
int r = 0;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = 0;
for (int i = 0; i < as.length; i++) {
r ^= as[i];
}
- return r;
+ }
+ bh.consume(r);
}
@Benchmark
- public int addAll() {
+ public void addAll(Blackhole bh) {
int[] as = fa.apply(size);
int r = 0;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = 0;
for (int i = 0; i < as.length; i++) {
r += as[i];
}
- return r;
+ }
+ bh.consume(r);
}
@Benchmark
- public int mulAll() {
+ public void mulAll(Blackhole bh) {
int[] as = fa.apply(size);
int r = 1;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = 1;
for (int i = 0; i < as.length; i++) {
r *= as[i];
}
- return r;
+ }
+ bh.consume(r);
}
@Benchmark
- public int minAll() {
+ public void minAll(Blackhole bh) {
int[] as = fa.apply(size);
int r = Integer.MAX_VALUE;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = Integer.MAX_VALUE;
for (int i = 0; i < as.length; i++) {
r = (int)Math.min(r, as[i]);
}
- return r;
+ }
+ bh.consume(r);
}
@Benchmark
- public int maxAll() {
+ public void maxAll(Blackhole bh) {
int[] as = fa.apply(size);
int r = Integer.MIN_VALUE;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = Integer.MIN_VALUE;
for (int i = 0; i < as.length; i++) {
r = (int)Math.max(r, as[i]);
}
- return r;
+ }
+ bh.consume(r);
}
@Benchmark
- public boolean anyTrue() {
+ public void anyTrue(Blackhole bh) {
boolean[] ms = fm.apply(size);
boolean r = false;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = false;
for (int i = 0; i < ms.length; i++) {
r |= ms[i];
}
- return r;
+ }
+ bh.consume(r);
}
@Benchmark
- public boolean allTrue() {
+ public void allTrue(Blackhole bh) {
boolean[] ms = fm.apply(size);
boolean r = true;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = true;
for (int i = 0; i < ms.length; i++) {
r &= ms[i];
}
- return r;
+ }
+ bh.consume(r);
}
@Benchmark
- public boolean lessThan() {
+ public void lessThan(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
boolean r = false;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = false;
for (int i = 0; i < as.length; i++) {
boolean m = (as[i] < bs[i]);
r |= m; // accumulate so JIT can't eliminate the computation
}
+ }
- return r;
+ bh.consume(r);
}
@Benchmark
- public boolean greaterThan() {
+ public void greaterThan(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
boolean r = false;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = false;
for (int i = 0; i < as.length; i++) {
boolean m = (as[i] > bs[i]);
r |= m; // accumulate so JIT can't eliminate the computation
}
+ }
- return r;
+ bh.consume(r);
}
@Benchmark
- public boolean equal() {
+ public void equal(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
boolean r = false;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = false;
for (int i = 0; i < as.length; i++) {
boolean m = (as[i] == bs[i]);
r |= m; // accumulate so JIT can't eliminate the computation
}
+ }
- return r;
+ bh.consume(r);
}
@Benchmark
- public boolean notEqual() {
+ public void notEqual(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
boolean r = false;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = false;
for (int i = 0; i < as.length; i++) {
boolean m = (as[i] != bs[i]);
r |= m; // accumulate so JIT can't eliminate the computation
}
+ }
- return r;
+ bh.consume(r);
}
@Benchmark
- public boolean lessThanEq() {
+ public void lessThanEq(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
boolean r = false;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = false;
for (int i = 0; i < as.length; i++) {
boolean m = (as[i] <= bs[i]);
r |= m; // accumulate so JIT can't eliminate the computation
}
+ }
- return r;
+ bh.consume(r);
}
@Benchmark
- public boolean greaterThanEq() {
+ public void greaterThanEq(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
boolean r = false;
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ r = false;
for (int i = 0; i < as.length; i++) {
boolean m = (as[i] >= bs[i]);
r |= m; // accumulate so JIT can't eliminate the computation
}
+ }
- return r;
+ bh.consume(r);
}
@Benchmark
- public Object blend() {
+ public void blend(Blackhole bh) {
int[] as = fa.apply(size);
int[] bs = fb.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
int b = bs[i];
boolean m = ms[i % ms.length];
rs[i] = (m ? b : a);
}
+ }
- return rs;
+ bh.consume(rs);
}
- Object rearrangeShared(int window) {
+ void rearrangeShared(int window, Blackhole bh) {
int[] as = fa.apply(size);
int[] order = fs.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i += window) {
for (int j = 0; j < window; j++) {
int a = as[i+j];
int pos = order[j];
rs[i + pos] = a;
}
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object rearrange064() {
+ public void rearrange064(Blackhole bh) {
int window = 64 / Integer.SIZE;
- return rearrangeShared(window);
+ rearrangeShared(window, bh);
}
@Benchmark
- public Object rearrange128() {
+ public void rearrange128(Blackhole bh) {
int window = 128 / Integer.SIZE;
- return rearrangeShared(window);
+ rearrangeShared(window, bh);
}
@Benchmark
- public Object rearrange256() {
+ public void rearrange256(Blackhole bh) {
int window = 256 / Integer.SIZE;
- return rearrangeShared(window);
+ rearrangeShared(window, bh);
}
@Benchmark
- public Object rearrange512() {
+ public void rearrange512(Blackhole bh) {
int window = 512 / Integer.SIZE;
- return rearrangeShared(window);
+ rearrangeShared(window, bh);
}
@@ -812,205 +916,225 @@
@Benchmark
- public Object neg() {
+ public void neg(Blackhole bh) {
int[] as = fa.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
rs[i] = (int)(-((int)a));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object negMasked() {
+ public void negMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
boolean m = ms[i % ms.length];
rs[i] = (m ? (int)(-((int)a)) : a);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object abs() {
+ public void abs(Blackhole bh) {
int[] as = fa.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
rs[i] = (int)(Math.abs((int)a));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object absMasked() {
+ public void absMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
boolean m = ms[i % ms.length];
rs[i] = (m ? (int)(Math.abs((int)a)) : a);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object not() {
+ public void not(Blackhole bh) {
int[] as = fa.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
rs[i] = (int)(~((int)a));
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object notMasked() {
+ public void notMasked(Blackhole bh) {
int[] as = fa.apply(size);
int[] rs = fr.apply(size);
boolean[] ms = fm.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int a = as[i];
boolean m = ms[i % ms.length];
rs[i] = (m ? (int)(~((int)a)) : a);
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object gatherBase0() {
+ public void gatherBase0(Blackhole bh) {
int[] as = fa.apply(size);
int[] is = fs.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int ix = 0 + is[i];
rs[i] = as[ix];
}
+ }
- return rs;
+ bh.consume(rs);
}
- Object gather(int window) {
+ void gather(int window, Blackhole bh) {
int[] as = fa.apply(size);
int[] is = fs.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i += window) {
for (int j = 0; j < window; j++) {
int ix = i + is[i + j];
rs[i + j] = as[ix];
}
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object gather064() {
+ public void gather064(Blackhole bh) {
int window = 64 / Integer.SIZE;
- return gather(window);
+ gather(window, bh);
}
@Benchmark
- public Object gather128() {
+ public void gather128(Blackhole bh) {
int window = 128 / Integer.SIZE;
- return gather(window);
+ gather(window, bh);
}
@Benchmark
- public Object gather256() {
+ public void gather256(Blackhole bh) {
int window = 256 / Integer.SIZE;
- return gather(window);
+ gather(window, bh);
}
@Benchmark
- public Object gather512() {
+ public void gather512(Blackhole bh) {
int window = 512 / Integer.SIZE;
- return gather(window);
+ gather(window, bh);
}
@Benchmark
- public Object scatterBase0() {
+ public void scatterBase0(Blackhole bh) {
int[] as = fa.apply(size);
int[] is = fs.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i++) {
int ix = 0 + is[i];
rs[ix] = as[i];
}
+ }
- return rs;
+ bh.consume(rs);
}
- Object scatter(int window) {
+ void scatter(int window, Blackhole bh) {
int[] as = fa.apply(size);
int[] is = fs.apply(size);
int[] rs = fr.apply(size);
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < as.length; i += window) {
for (int j = 0; j < window; j++) {
int ix = i + is[i + j];
rs[ix] = as[i + j];
}
}
+ }
- return rs;
+ bh.consume(rs);
}
@Benchmark
- public Object scatter064() {
+ public void scatter064(Blackhole bh) {
int window = 64 / Integer.SIZE;
- return scatter(window);
+ scatter(window, bh);
}
@Benchmark
- public Object scatter128() {
+ public void scatter128(Blackhole bh) {
int window = 128 / Integer.SIZE;
- return scatter(window);
+ scatter(window, bh);
}
@Benchmark
- public Object scatter256() {
+ public void scatter256(Blackhole bh) {
int window = 256 / Integer.SIZE;
- return scatter(window);
+ scatter(window, bh);
}
@Benchmark
- public Object scatter512() {
+ public void scatter512(Blackhole bh) {
int window = 512 / Integer.SIZE;
- return scatter(window);
+ scatter(window, bh);
}
}
< prev index next >