29 import java.nio.DoubleBuffer;
30 import java.nio.ReadOnlyBufferException;
31 import java.util.Arrays;
32 import java.util.Objects;
33 import java.util.function.IntUnaryOperator;
34
35 import jdk.internal.misc.Unsafe;
36 import jdk.internal.vm.annotation.ForceInline;
37 import static jdk.incubator.vector.VectorIntrinsics.*;
38
39 @SuppressWarnings("cast")
40 final class DoubleMaxVector extends DoubleVector {
41 static final DoubleMaxSpecies SPECIES = new DoubleMaxSpecies();
42
43 static final DoubleMaxVector ZERO = new DoubleMaxVector();
44
45 static final int LENGTH = SPECIES.length();
46
47 // Index vector species
48 private static final IntVector.IntSpecies INDEX_SPEC;
49 static {
50 int bitSize = Vector.bitSizeForVectorLength(int.class, LENGTH);
51 Vector.Shape shape = Shape.forBitSize(bitSize);
52 INDEX_SPEC = (IntVector.IntSpecies) Species.of(int.class, shape);
53 }
54 private final double[] vec; // Don't access directly, use getElements() instead.
55
56 private double[] getElements() {
57 return VectorIntrinsics.maybeRebox(this).vec;
58 }
59
60 DoubleMaxVector() {
61 vec = new double[SPECIES.length()];
62 }
63
64 DoubleMaxVector(double[] v) {
65 vec = v;
66 }
67
68 @Override
69 public int length() { return LENGTH; }
70
71 // Unary operator
72
944 a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_DOUBLE_BASE_OFFSET,
945 this,
946 a, ix,
947 (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
948 }
949
950 @Override
951 @ForceInline
952 public final void intoArray(double[] a, int ax, Mask<Double> m) {
953 DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
954 DoubleVector newVal = oldVal.blend(this, m);
955 newVal.intoArray(a, ax);
956 }
957 @Override
958 @ForceInline
959 public void intoArray(double[] a, int ix, int[] b, int iy) {
960 Objects.requireNonNull(a);
961 Objects.requireNonNull(b);
962
963 // Index vector: vix[0:n] = i -> ix + indexMap[iy + i]
964 IntVector vix = IntVector.fromArray(INDEX_SPEC, b, iy).add(ix);
965
966 vix = VectorIntrinsics.checkIndex(vix, a.length);
967
968 VectorIntrinsics.storeWithMap(DoubleMaxVector.class, double.class, LENGTH, vix.getClass(),
969 a, Unsafe.ARRAY_DOUBLE_BASE_OFFSET, vix,
970 this,
971 a, ix, b, iy,
972 (arr, idx, v, indexMap, idy) -> v.forEach((i, e) -> arr[idx+indexMap[idy+i]] = e));
973 }
974
975 @Override
976 @ForceInline
977 public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
978 // @@@ This can result in out of bounds errors for unset mask lanes
979 DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
980 DoubleVector newVal = oldVal.blend(this, m);
981 newVal.intoArray(a, ax, b, iy);
982 }
983
984 @Override
1504 public int elementSize() {
1505 return Double.SIZE;
1506 }
1507
1508 @Override
1509 @ForceInline
1510 @SuppressWarnings("unchecked")
1511 Class<?> vectorType() {
1512 return DoubleMaxVector.class;
1513 }
1514
1515 @Override
1516 @ForceInline
1517 public Shape shape() {
1518 return Shape.S_Max_BIT;
1519 }
1520
1521 @Override
1522 IntVector.IntSpecies indexSpecies() {
1523 return INDEX_SPEC;
1524 }
1525
1526 @Override
1527 DoubleMaxVector op(FOp f) {
1528 double[] res = new double[length()];
1529 for (int i = 0; i < length(); i++) {
1530 res[i] = f.apply(i);
1531 }
1532 return new DoubleMaxVector(res);
1533 }
1534
1535 @Override
1536 DoubleMaxVector op(Mask<Double> o, FOp f) {
1537 double[] res = new double[length()];
1538 boolean[] mbits = ((DoubleMaxMask)o).getBits();
1539 for (int i = 0; i < length(); i++) {
1540 if (mbits[i]) {
1541 res[i] = f.apply(i);
1542 }
1543 }
|
29 import java.nio.DoubleBuffer;
30 import java.nio.ReadOnlyBufferException;
31 import java.util.Arrays;
32 import java.util.Objects;
33 import java.util.function.IntUnaryOperator;
34
35 import jdk.internal.misc.Unsafe;
36 import jdk.internal.vm.annotation.ForceInline;
37 import static jdk.incubator.vector.VectorIntrinsics.*;
38
39 @SuppressWarnings("cast")
40 final class DoubleMaxVector extends DoubleVector {
41 static final DoubleMaxSpecies SPECIES = new DoubleMaxSpecies();
42
43 static final DoubleMaxVector ZERO = new DoubleMaxVector();
44
45 static final int LENGTH = SPECIES.length();
46
47 // Index vector species
48 private static final IntVector.IntSpecies INDEX_SPEC;
49 private static final Mask<Integer> INDEX_MASK;
50 static {
51 int bitSize = Vector.bitSizeForVectorLength(double.class, LENGTH);
52 Vector.Shape shape = Shape.forBitSize(bitSize);
53 INDEX_SPEC = (IntVector.IntSpecies) Species.of(int.class, shape);
54 boolean[] mask = new boolean[INDEX_SPEC.length()];
55 Arrays.fill(mask, 0, LENGTH, true);
56 INDEX_MASK = IntVector.maskFromArray(INDEX_SPEC, mask, 0);
57 }
58 private final double[] vec; // Don't access directly, use getElements() instead.
59
60 private double[] getElements() {
61 return VectorIntrinsics.maybeRebox(this).vec;
62 }
63
64 DoubleMaxVector() {
65 vec = new double[SPECIES.length()];
66 }
67
68 DoubleMaxVector(double[] v) {
69 vec = v;
70 }
71
72 @Override
73 public int length() { return LENGTH; }
74
75 // Unary operator
76
948 a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_DOUBLE_BASE_OFFSET,
949 this,
950 a, ix,
951 (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
952 }
953
954 @Override
955 @ForceInline
956 public final void intoArray(double[] a, int ax, Mask<Double> m) {
957 DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
958 DoubleVector newVal = oldVal.blend(this, m);
959 newVal.intoArray(a, ax);
960 }
961 @Override
962 @ForceInline
963 public void intoArray(double[] a, int ix, int[] b, int iy) {
964 Objects.requireNonNull(a);
965 Objects.requireNonNull(b);
966
967 // Index vector: vix[0:n] = i -> ix + indexMap[iy + i]
968 IntVector vix = IntVector.fromArray(INDEX_SPEC, b, iy, INDEX_MASK).add(ix);
969
970 vix = VectorIntrinsics.checkIndex(vix, a.length);
971
972 VectorIntrinsics.storeWithMap(DoubleMaxVector.class, double.class, LENGTH, vix.getClass(),
973 a, Unsafe.ARRAY_DOUBLE_BASE_OFFSET, vix,
974 this,
975 a, ix, b, iy,
976 (arr, idx, v, indexMap, idy) -> v.forEach((i, e) -> arr[idx+indexMap[idy+i]] = e));
977 }
978
979 @Override
980 @ForceInline
981 public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
982 // @@@ This can result in out of bounds errors for unset mask lanes
983 DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
984 DoubleVector newVal = oldVal.blend(this, m);
985 newVal.intoArray(a, ax, b, iy);
986 }
987
988 @Override
1508 public int elementSize() {
1509 return Double.SIZE;
1510 }
1511
1512 @Override
1513 @ForceInline
1514 @SuppressWarnings("unchecked")
1515 Class<?> vectorType() {
1516 return DoubleMaxVector.class;
1517 }
1518
1519 @Override
1520 @ForceInline
1521 public Shape shape() {
1522 return Shape.S_Max_BIT;
1523 }
1524
1525 @Override
1526 IntVector.IntSpecies indexSpecies() {
1527 return INDEX_SPEC;
1528 }
1529
1530 @Override
1531 Mask<Integer> indexMask() {
1532 return INDEX_MASK;
1533 }
1534
1535 @Override
1536 DoubleMaxVector op(FOp f) {
1537 double[] res = new double[length()];
1538 for (int i = 0; i < length(); i++) {
1539 res[i] = f.apply(i);
1540 }
1541 return new DoubleMaxVector(res);
1542 }
1543
1544 @Override
1545 DoubleMaxVector op(Mask<Double> o, FOp f) {
1546 double[] res = new double[length()];
1547 boolean[] mbits = ((DoubleMaxMask)o).getBits();
1548 for (int i = 0; i < length(); i++) {
1549 if (mbits[i]) {
1550 res[i] = f.apply(i);
1551 }
1552 }
|