< prev index next >
test/jdk/jdk/incubator/vector/benchmark/src/main/java/benchmark/jdk/incubator/vector/Byte64Vector.java
Print this page
rev 55894 : 8222897: [vector] Renaming of shift, rotate operations. Few other api changes.
Summary: Renaming of shift, rotate operations. Few other api changes.
Reviewed-by: jrose, briangoetz
@@ -22,10 +22,11 @@
*/
package benchmark.jdk.incubator.vector;
import jdk.incubator.vector.Vector;
+import jdk.incubator.vector.VectorMask;
import jdk.incubator.vector.VectorShape;
import jdk.incubator.vector.VectorSpecies;
import jdk.incubator.vector.VectorShuffle;
import jdk.incubator.vector.ByteVector;
@@ -317,126 +318,214 @@
+ @Benchmark
+ public void shiftLeft(Blackhole bh) {
+ byte[] a = fa.apply(SPECIES.length());
+ byte[] b = fb.apply(SPECIES.length());
+ byte[] r = fr.apply(SPECIES.length());
+
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ for (int i = 0; i < a.length; i += SPECIES.length()) {
+ ByteVector av = ByteVector.fromArray(SPECIES, a, i);
+ ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
+ av.shiftLeft(bv).intoArray(r, i);
+ }
+ }
+
+ bh.consume(r);
+ }
+
+ @Benchmark
+ public void shiftLeftMasked(Blackhole bh) {
+ byte[] a = fa.apply(SPECIES.length());
+ byte[] b = fb.apply(SPECIES.length());
+ byte[] r = fr.apply(SPECIES.length());
+ boolean[] mask = fm.apply(SPECIES.length());
+ VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask);
+
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ for (int i = 0; i < a.length; i += SPECIES.length()) {
+ ByteVector av = ByteVector.fromArray(SPECIES, a, i);
+ ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
+ av.shiftLeft(bv, vmask).intoArray(r, i);
+ }
+ }
+
+ bh.consume(r);
+ }
+
+
+
+
+
+
+
+ @Benchmark
+ public void shiftRight(Blackhole bh) {
+ byte[] a = fa.apply(SPECIES.length());
+ byte[] b = fb.apply(SPECIES.length());
+ byte[] r = fr.apply(SPECIES.length());
+
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ for (int i = 0; i < a.length; i += SPECIES.length()) {
+ ByteVector av = ByteVector.fromArray(SPECIES, a, i);
+ ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
+ av.shiftRight(bv).intoArray(r, i);
+ }
+ }
+
+ bh.consume(r);
+ }
+
+
+
+ @Benchmark
+ public void shiftRightMasked(Blackhole bh) {
+ byte[] a = fa.apply(SPECIES.length());
+ byte[] b = fb.apply(SPECIES.length());
+ byte[] r = fr.apply(SPECIES.length());
+ boolean[] mask = fm.apply(SPECIES.length());
+ VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask);
+
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ for (int i = 0; i < a.length; i += SPECIES.length()) {
+ ByteVector av = ByteVector.fromArray(SPECIES, a, i);
+ ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
+ av.shiftRight(bv, vmask).intoArray(r, i);
+ }
+ }
+ bh.consume(r);
+ }
@Benchmark
- public void aShiftRShift(Blackhole bh) {
+ public void shiftArithmeticRight(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- av.aShiftR((int)b[i]).intoArray(r, i);
+ ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
+ av.shiftArithmeticRight(bv).intoArray(r, i);
}
}
bh.consume(r);
}
@Benchmark
- public void aShiftRMaskedShift(Blackhole bh) {
+ public void shiftArithmeticRightMasked(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- av.aShiftR((int)b[i], vmask).intoArray(r, i);
+ ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
+ av.shiftArithmeticRight(bv, vmask).intoArray(r, i);
}
}
bh.consume(r);
}
+
+
+
+
@Benchmark
- public void shiftLShift(Blackhole bh) {
+ public void shiftLeftShift(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- av.shiftL((int)b[i]).intoArray(r, i);
+ av.shiftLeft((int)b[i]).intoArray(r, i);
}
}
bh.consume(r);
}
@Benchmark
- public void shiftLMaskedShift(Blackhole bh) {
+ public void shiftLeftMaskedShift(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- av.shiftL((int)b[i], vmask).intoArray(r, i);
+ av.shiftLeft((int)b[i], vmask).intoArray(r, i);
}
}
bh.consume(r);
}
+
+
+
+
@Benchmark
- public void shiftRShift(Blackhole bh) {
+ public void shiftRightShift(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- av.shiftR((int)b[i]).intoArray(r, i);
+ av.shiftRight((int)b[i]).intoArray(r, i);
}
}
bh.consume(r);
}
@Benchmark
- public void shiftRMaskedShift(Blackhole bh) {
+ public void shiftRightMaskedShift(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
byte[] r = fr.apply(SPECIES.length());
boolean[] mask = fm.apply(SPECIES.length());
VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- av.shiftR((int)b[i], vmask).intoArray(r, i);
+ av.shiftRight((int)b[i], vmask).intoArray(r, i);
}
}
bh.consume(r);
}
@@ -445,10 +534,48 @@
+ @Benchmark
+ public void shiftArithmeticRightShift(Blackhole bh) {
+ byte[] a = fa.apply(SPECIES.length());
+ byte[] b = fb.apply(SPECIES.length());
+ byte[] r = fr.apply(SPECIES.length());
+
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ for (int i = 0; i < a.length; i += SPECIES.length()) {
+ ByteVector av = ByteVector.fromArray(SPECIES, a, i);
+ av.shiftArithmeticRight((int)b[i]).intoArray(r, i);
+ }
+ }
+
+ bh.consume(r);
+ }
+
+
+
+ @Benchmark
+ public void shiftArithmeticRightMaskedShift(Blackhole bh) {
+ byte[] a = fa.apply(SPECIES.length());
+ byte[] b = fb.apply(SPECIES.length());
+ byte[] r = fr.apply(SPECIES.length());
+ boolean[] mask = fm.apply(SPECIES.length());
+ VectorMask<Byte> vmask = VectorMask.fromValues(SPECIES, mask);
+
+ for (int ic = 0; ic < INVOC_COUNT; ic++) {
+ for (int i = 0; i < a.length; i += SPECIES.length()) {
+ ByteVector av = ByteVector.fromArray(SPECIES, a, i);
+ av.shiftArithmeticRight((int)b[i], vmask).intoArray(r, i);
+ }
+ }
+
+ bh.consume(r);
+ }
+
+
+
@Benchmark
public void max(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte[] b = fb.apply(SPECIES.length());
@@ -482,114 +609,114 @@
bh.consume(r);
}
@Benchmark
- public void andAll(Blackhole bh) {
+ public void andLanes(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte ra = -1;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = -1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- ra &= av.andAll();
+ ra &= av.andLanes();
}
}
bh.consume(ra);
}
@Benchmark
- public void orAll(Blackhole bh) {
+ public void orLanes(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte ra = 0;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- ra |= av.orAll();
+ ra |= av.orLanes();
}
}
bh.consume(ra);
}
@Benchmark
- public void xorAll(Blackhole bh) {
+ public void xorLanes(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte ra = 0;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- ra ^= av.xorAll();
+ ra ^= av.xorLanes();
}
}
bh.consume(ra);
}
@Benchmark
- public void addAll(Blackhole bh) {
+ public void addLanes(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte ra = 0;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 0;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- ra += av.addAll();
+ ra += av.addLanes();
}
}
bh.consume(ra);
}
@Benchmark
- public void mulAll(Blackhole bh) {
+ public void mulLanes(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte ra = 1;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = 1;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- ra *= av.mulAll();
+ ra *= av.mulLanes();
}
}
bh.consume(ra);
}
@Benchmark
- public void minAll(Blackhole bh) {
+ public void minLanes(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte ra = Byte.MAX_VALUE;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = Byte.MAX_VALUE;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- ra = (byte)Math.min(ra, av.minAll());
+ ra = (byte)Math.min(ra, av.minLanes());
}
}
bh.consume(ra);
}
@Benchmark
- public void maxAll(Blackhole bh) {
+ public void maxLanes(Blackhole bh) {
byte[] a = fa.apply(SPECIES.length());
byte ra = Byte.MIN_VALUE;
for (int ic = 0; ic < INVOC_COUNT; ic++) {
ra = Byte.MIN_VALUE;
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
- ra = (byte)Math.max(ra, av.maxAll());
+ ra = (byte)Math.max(ra, av.maxLanes());
}
}
bh.consume(ra);
}
@@ -645,11 +772,11 @@
@Benchmark
public Object lessThan() {
byte[] a = fa.apply(size);
byte[] b = fb.apply(size);
boolean[] ms = fm.apply(size);
- VectorMask<Byte> m = VectorMask.maskFromArray(SPECIES, ms, 0);
+ VectorMask<Byte> m = VectorMask.fromArray(SPECIES, ms, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
@@ -665,11 +792,11 @@
@Benchmark
public Object greaterThan() {
byte[] a = fa.apply(size);
byte[] b = fb.apply(size);
boolean[] ms = fm.apply(size);
- VectorMask<Byte> m = VectorMask.maskFromArray(SPECIES, ms, 0);
+ VectorMask<Byte> m = VectorMask.fromArray(SPECIES, ms, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
@@ -685,11 +812,11 @@
@Benchmark
public Object equal() {
byte[] a = fa.apply(size);
byte[] b = fb.apply(size);
boolean[] ms = fm.apply(size);
- VectorMask<Byte> m = VectorMask.maskFromArray(SPECIES, ms, 0);
+ VectorMask<Byte> m = VectorMask.fromArray(SPECIES, ms, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
@@ -705,11 +832,11 @@
@Benchmark
public Object notEqual() {
byte[] a = fa.apply(size);
byte[] b = fb.apply(size);
boolean[] ms = fm.apply(size);
- VectorMask<Byte> m = VectorMask.maskFromArray(SPECIES, ms, 0);
+ VectorMask<Byte> m = VectorMask.fromArray(SPECIES, ms, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
@@ -725,11 +852,11 @@
@Benchmark
public Object lessThanEq() {
byte[] a = fa.apply(size);
byte[] b = fb.apply(size);
boolean[] ms = fm.apply(size);
- VectorMask<Byte> m = VectorMask.maskFromArray(SPECIES, ms, 0);
+ VectorMask<Byte> m = VectorMask.fromArray(SPECIES, ms, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
@@ -745,11 +872,11 @@
@Benchmark
public Object greaterThanEq() {
byte[] a = fa.apply(size);
byte[] b = fb.apply(size);
boolean[] ms = fm.apply(size);
- VectorMask<Byte> m = VectorMask.maskFromArray(SPECIES, ms, 0);
+ VectorMask<Byte> m = VectorMask.fromArray(SPECIES, ms, 0);
for (int ic = 0; ic < INVOC_COUNT; ic++) {
for (int i = 0; i < a.length; i += SPECIES.length()) {
ByteVector av = ByteVector.fromArray(SPECIES, a, i);
ByteVector bv = ByteVector.fromArray(SPECIES, b, i);
< prev index next >