--- old/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java 2019-04-11 15:41:51.758533800 -0700 +++ new/src/jdk.incubator.vector/share/classes/jdk/incubator/vector/LongVector.java 2019-04-11 15:41:51.125108400 -0700 @@ -464,230 +464,6 @@ return ((LongSpecies)s).op(i -> r.nextLong()); } - /** - * Returns a mask where each lane is set or unset according to given - * {@code boolean} values - *

- * For each mask lane, where {@code N} is the mask lane index, - * if the given {@code boolean} value at index {@code N} is {@code true} - * then the mask lane at index {@code N} is set, otherwise it is unset. - * - * @param species mask species - * @param bits the given {@code boolean} values - * @return a mask where each lane is set or unset according to the given {@code boolean} value - * @throws IndexOutOfBoundsException if {@code bits.length < species.length()} - */ - @ForceInline - public static Mask maskFromValues(Species species, boolean... bits) { - if (species.boxType() == LongMaxVector.class) - return new LongMaxVector.LongMaxMask(bits); - switch (species.bitSize()) { - case 64: return new Long64Vector.Long64Mask(bits); - case 128: return new Long128Vector.Long128Mask(bits); - case 256: return new Long256Vector.Long256Mask(bits); - case 512: return new Long512Vector.Long512Mask(bits); - default: throw new IllegalArgumentException(Integer.toString(species.bitSize())); - } - } - - // @@@ This is a bad implementation -- makes lambdas capturing -- fix this - static Mask trueMask(Species species) { - if (species.boxType() == LongMaxVector.class) - return LongMaxVector.LongMaxMask.TRUE_MASK; - switch (species.bitSize()) { - case 64: return Long64Vector.Long64Mask.TRUE_MASK; - case 128: return Long128Vector.Long128Mask.TRUE_MASK; - case 256: return Long256Vector.Long256Mask.TRUE_MASK; - case 512: return Long512Vector.Long512Mask.TRUE_MASK; - default: throw new IllegalArgumentException(Integer.toString(species.bitSize())); - } - } - - static Mask falseMask(Species species) { - if (species.boxType() == LongMaxVector.class) - return LongMaxVector.LongMaxMask.FALSE_MASK; - switch (species.bitSize()) { - case 64: return Long64Vector.Long64Mask.FALSE_MASK; - case 128: return Long128Vector.Long128Mask.FALSE_MASK; - case 256: return Long256Vector.Long256Mask.FALSE_MASK; - case 512: return Long512Vector.Long512Mask.FALSE_MASK; - default: throw new IllegalArgumentException(Integer.toString(species.bitSize())); - } - } - - /** - * Loads a mask from a {@code boolean} array starting at an offset. - *

- * For each mask lane, where {@code N} is the mask lane index, - * if the array element at index {@code ix + N} is {@code true} then the - * mask lane at index {@code N} is set, otherwise it is unset. - * - * @param species mask species - * @param bits the {@code boolean} array - * @param ix the offset into the array - * @return the mask loaded from a {@code boolean} array - * @throws IndexOutOfBoundsException if {@code ix < 0}, or - * {@code ix > bits.length - species.length()} - */ - @ForceInline - @SuppressWarnings("unchecked") - public static Mask maskFromArray(Species species, boolean[] bits, int ix) { - Objects.requireNonNull(bits); - ix = VectorIntrinsics.checkIndex(ix, bits.length, species.length()); - return VectorIntrinsics.load((Class>) species.maskType(), long.class, species.length(), - bits, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_BOOLEAN_BASE_OFFSET, - bits, ix, species, - (c, idx, s) -> (Mask) ((LongSpecies)s).opm(n -> c[idx + n])); - } - - /** - * Returns a mask where all lanes are set. - * - * @param species mask species - * @return a mask where all lanes are set - */ - @ForceInline - @SuppressWarnings("unchecked") - public static Mask maskAllTrue(Species species) { - return VectorIntrinsics.broadcastCoerced((Class>) species.maskType(), long.class, species.length(), - (long)-1, species, - ((z, s) -> trueMask(s))); - } - - /** - * Returns a mask where all lanes are unset. - * - * @param species mask species - * @return a mask where all lanes are unset - */ - @ForceInline - @SuppressWarnings("unchecked") - public static Mask maskAllFalse(Species species) { - return VectorIntrinsics.broadcastCoerced((Class>) species.maskType(), long.class, species.length(), - 0, species, - ((z, s) -> falseMask(s))); - } - - /** - * Returns a shuffle of mapped indexes where each lane element is - * the result of applying a mapping function to the corresponding lane - * index. - *

- * Care should be taken to ensure Shuffle values produced from this - * method are consumed as constants to ensure optimal generation of - * code. For example, values held in static final fields or values - * held in loop constant local variables. - *

- * This method behaves as if a shuffle is created from an array of - * mapped indexes as follows: - * 

{@code
-     *   int[] a = new int[species.length()];
-     *   for (int i = 0; i < a.length; i++) {
-     *       a[i] = f.applyAsInt(i);
-     *   }
-     *   return this.shuffleFromValues(a);
-     * }
- * - * @param species shuffle species - * @param f the lane index mapping function - * @return a shuffle of mapped indexes - */ - @ForceInline - public static Shuffle shuffle(Species species, IntUnaryOperator f) { - if (species.boxType() == LongMaxVector.class) - return new LongMaxVector.LongMaxShuffle(f); - switch (species.bitSize()) { - case 64: return new Long64Vector.Long64Shuffle(f); - case 128: return new Long128Vector.Long128Shuffle(f); - case 256: return new Long256Vector.Long256Shuffle(f); - case 512: return new Long512Vector.Long512Shuffle(f); - default: throw new IllegalArgumentException(Integer.toString(species.bitSize())); - } - } - - /** - * Returns a shuffle where each lane element is the value of its - * corresponding lane index. - *

- * This method behaves as if a shuffle is created from an identity - * index mapping function as follows: - * 

{@code
-     *   return this.shuffle(i -> i);
-     * }
- * - * @param species shuffle species - * @return a shuffle of lane indexes - */ - @ForceInline - public static Shuffle shuffleIota(Species species) { - if (species.boxType() == LongMaxVector.class) - return new LongMaxVector.LongMaxShuffle(AbstractShuffle.IDENTITY); - switch (species.bitSize()) { - case 64: return new Long64Vector.Long64Shuffle(AbstractShuffle.IDENTITY); - case 128: return new Long128Vector.Long128Shuffle(AbstractShuffle.IDENTITY); - case 256: return new Long256Vector.Long256Shuffle(AbstractShuffle.IDENTITY); - case 512: return new Long512Vector.Long512Shuffle(AbstractShuffle.IDENTITY); - default: throw new IllegalArgumentException(Integer.toString(species.bitSize())); - } - } - - /** - * Returns a shuffle where each lane element is set to a given - * {@code int} value logically AND'ed by the species length minus one. - *

- * For each shuffle lane, where {@code N} is the shuffle lane index, the - * the {@code int} value at index {@code N} logically AND'ed by - * {@code species.length() - 1} is placed into the resulting shuffle at - * lane index {@code N}. - * - * @param species shuffle species - * @param ixs the given {@code int} values - * @return a shuffle where each lane element is set to a given - * {@code int} value - * @throws IndexOutOfBoundsException if the number of int values is - * {@code < species.length()} - */ - @ForceInline - public static Shuffle shuffleFromValues(Species species, int... ixs) { - if (species.boxType() == LongMaxVector.class) - return new LongMaxVector.LongMaxShuffle(ixs); - switch (species.bitSize()) { - case 64: return new Long64Vector.Long64Shuffle(ixs); - case 128: return new Long128Vector.Long128Shuffle(ixs); - case 256: return new Long256Vector.Long256Shuffle(ixs); - case 512: return new Long512Vector.Long512Shuffle(ixs); - default: throw new IllegalArgumentException(Integer.toString(species.bitSize())); - } - } - - /** - * Loads a shuffle from an {@code int} array starting at an offset. - *

- * For each shuffle lane, where {@code N} is the shuffle lane index, the - * array element at index {@code i + N} logically AND'ed by - * {@code species.length() - 1} is placed into the resulting shuffle at lane - * index {@code N}. - * - * @param species shuffle species - * @param ixs the {@code int} array - * @param i the offset into the array - * @return a shuffle loaded from the {@code int} array - * @throws IndexOutOfBoundsException if {@code i < 0}, or - * {@code i > a.length - species.length()} - */ - @ForceInline - public static Shuffle shuffleFromArray(Species species, int[] ixs, int i) { - if (species.boxType() == LongMaxVector.class) - return new LongMaxVector.LongMaxShuffle(ixs, i); - switch (species.bitSize()) { - case 64: return new Long64Vector.Long64Shuffle(ixs, i); - case 128: return new Long128Vector.Long128Shuffle(ixs, i); - case 256: return new Long256Vector.Long256Shuffle(ixs, i); - case 512: return new Long512Vector.Long512Shuffle(ixs, i); - default: throw new IllegalArgumentException(Integer.toString(species.bitSize())); - } - } - // Ops @Override @@ -1702,20 +1478,21 @@ public abstract Species species(); /** - * Class representing {@link LongVector}'s of the same {@link Vector.Shape Shape}. + * Class representing {@link LongVector}'s of the same {@link Shape Shape}. */ - static final class LongSpecies extends Vector.AbstractSpecies { + static final class LongSpecies extends AbstractSpecies { final Function vectorFactory; - final Function> maskFactory; - private LongSpecies(Vector.Shape shape, + private LongSpecies(Shape shape, Class boxType, Class maskType, Function vectorFactory, - Function> maskFactory) { - super(shape, long.class, Long.SIZE, boxType, maskType); + Function> maskFactory, + Function> shuffleFromArrayFactory, + fShuffleFromArray shuffleFromOpFactory) { + super(shape, long.class, Long.SIZE, boxType, maskType, maskFactory, + shuffleFromArrayFactory, shuffleFromOpFactory); this.vectorFactory = vectorFactory; - this.maskFactory = maskFactory; } interface FOp { @@ -1734,7 +1511,7 @@ return vectorFactory.apply(res); } - LongVector op(Vector.Mask o, FOp f) { + LongVector op(Mask o, FOp f) { long[] res = new long[length()]; boolean[] mbits = ((AbstractMask)o).getBits(); for (int i = 0; i < length(); i++) { @@ -1744,14 +1521,6 @@ } return vectorFactory.apply(res); } - - Vector.Mask opm(IntVector.IntSpecies.FOpm f) { - boolean[] res = new boolean[length()]; - for (int i = 0; i < length(); i++) { - res[i] = (boolean)f.apply(i); - } - return maskFactory.apply(res); - } } /** @@ -1775,7 +1544,7 @@ * @return a species for an element type of {@code long} and shape * @throws IllegalArgumentException if no such species exists for the shape */ - static LongSpecies species(Vector.Shape s) { + static LongSpecies species(Shape s) { Objects.requireNonNull(s); switch (s) { case S_64_BIT: return (LongSpecies) SPECIES_64; @@ -1787,25 +1556,30 @@ } } - /** Species representing {@link LongVector}s of {@link Vector.Shape#S_64_BIT Shape.S_64_BIT}. */ + /** Species representing {@link LongVector}s of {@link Shape#S_64_BIT Shape.S_64_BIT}. */ public static final Species SPECIES_64 = new LongSpecies(Shape.S_64_BIT, Long64Vector.class, Long64Vector.Long64Mask.class, - Long64Vector::new, Long64Vector.Long64Mask::new); + Long64Vector::new, Long64Vector.Long64Mask::new, + Long64Vector.Long64Shuffle::new, Long64Vector.Long64Shuffle::new); - /** Species representing {@link LongVector}s of {@link Vector.Shape#S_128_BIT Shape.S_128_BIT}. */ + /** Species representing {@link LongVector}s of {@link Shape#S_128_BIT Shape.S_128_BIT}. */ public static final Species SPECIES_128 = new LongSpecies(Shape.S_128_BIT, Long128Vector.class, Long128Vector.Long128Mask.class, - Long128Vector::new, Long128Vector.Long128Mask::new); + Long128Vector::new, Long128Vector.Long128Mask::new, + Long128Vector.Long128Shuffle::new, Long128Vector.Long128Shuffle::new); - /** Species representing {@link LongVector}s of {@link Vector.Shape#S_256_BIT Shape.S_256_BIT}. */ + /** Species representing {@link LongVector}s of {@link Shape#S_256_BIT Shape.S_256_BIT}. */ public static final Species SPECIES_256 = new LongSpecies(Shape.S_256_BIT, Long256Vector.class, Long256Vector.Long256Mask.class, - Long256Vector::new, Long256Vector.Long256Mask::new); + Long256Vector::new, Long256Vector.Long256Mask::new, + Long256Vector.Long256Shuffle::new, Long256Vector.Long256Shuffle::new); - /** Species representing {@link LongVector}s of {@link Vector.Shape#S_512_BIT Shape.S_512_BIT}. */ + /** Species representing {@link LongVector}s of {@link Shape#S_512_BIT Shape.S_512_BIT}. */ public static final Species SPECIES_512 = new LongSpecies(Shape.S_512_BIT, Long512Vector.class, Long512Vector.Long512Mask.class, - Long512Vector::new, Long512Vector.Long512Mask::new); + Long512Vector::new, Long512Vector.Long512Mask::new, + Long512Vector.Long512Shuffle::new, Long512Vector.Long512Shuffle::new); - /** Species representing {@link LongVector}s of {@link Vector.Shape#S_Max_BIT Shape.S_Max_BIT}. */ + /** Species representing {@link LongVector}s of {@link Shape#S_Max_BIT Shape.S_Max_BIT}. */ public static final Species SPECIES_MAX = new LongSpecies(Shape.S_Max_BIT, LongMaxVector.class, LongMaxVector.LongMaxMask.class, - LongMaxVector::new, LongMaxVector.LongMaxMask::new); + LongMaxVector::new, LongMaxVector.LongMaxMask::new, + LongMaxVector.LongMaxShuffle::new, LongMaxVector.LongMaxShuffle::new); /** * Preferred species for {@link LongVector}s.