< prev index next >

src/jdk.incubator.vector/share/classes/jdk/incubator/vector/Byte128Vector.java

Print this page




 801     @Override
 802     @ForceInline
 803     public byte minAll(Mask<Byte> m) {
 804         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, Byte.MAX_VALUE), m).minAll();
 805     }
 806 
 807     @Override
 808     @ForceInline
 809     public byte maxAll(Mask<Byte> m) {
 810         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, Byte.MIN_VALUE), m).maxAll();
 811     }
 812 
 813     @Override
 814     @ForceInline
 815     public Shuffle<Byte> toShuffle() {
 816         byte[] a = toArray();
 817         int[] sa = new int[a.length];
 818         for (int i = 0; i < a.length; i++) {
 819             sa[i] = (int) a[i];
 820         }
 821         return ByteVector.shuffleFromArray(SPECIES, sa, 0);
 822     }
 823 
 824     // Memory operations
 825 
 826     private static final int ARRAY_SHIFT         = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BYTE_INDEX_SCALE);
 827     private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE);
 828 
 829     @Override
 830     @ForceInline
 831     public void intoArray(byte[] a, int ix) {
 832         Objects.requireNonNull(a);
 833         ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
 834         VectorIntrinsics.store(Byte128Vector.class, byte.class, LENGTH,
 835                                a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 836                                this,
 837                                a, ix,
 838                                (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
 839     }
 840 
 841     @Override


1262             Byte128Mask m = (Byte128Mask)o;
1263             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Byte128Mask.class, byte.class, LENGTH,
1264                                              this, m,
1265                                              (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b));
1266         }
1267 
1268         // Reductions
1269 
1270         @Override
1271         @ForceInline
1272         public boolean anyTrue() {
1273             return VectorIntrinsics.test(BT_ne, Byte128Mask.class, byte.class, LENGTH,
1274                                          this, this,
1275                                          (m, __) -> anyTrueHelper(((Byte128Mask)m).getBits()));
1276         }
1277 
1278         @Override
1279         @ForceInline
1280         public boolean allTrue() {
1281             return VectorIntrinsics.test(BT_overflow, Byte128Mask.class, byte.class, LENGTH,
1282                                          this, ByteVector.maskAllTrue(species()),
1283                                          (m, __) -> allTrueHelper(((Byte128Mask)m).getBits()));
1284         }
1285     }
1286 
1287     // Shuffle
1288 
1289     static final class Byte128Shuffle extends AbstractShuffle<Byte> {
1290         Byte128Shuffle(byte[] reorder) {
1291             super(reorder);
1292         }
1293 
1294         public Byte128Shuffle(int[] reorder) {
1295             super(reorder);
1296         }
1297 
1298         public Byte128Shuffle(int[] reorder, int i) {
1299             super(reorder, i);
1300         }
1301 
1302         public Byte128Shuffle(IntUnaryOperator f) {


1326             Class<?> stype = species.elementType();
1327             int [] shuffleArray = toArray();
1328             if (stype == byte.class) {
1329                 return (Shuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
1330             } else if (stype == short.class) {
1331                 return (Shuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
1332             } else if (stype == int.class) {
1333                 return (Shuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
1334             } else if (stype == long.class) {
1335                 return (Shuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
1336             } else if (stype == float.class) {
1337                 return (Shuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
1338             } else if (stype == double.class) {
1339                 return (Shuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
1340             } else {
1341                 throw new UnsupportedOperationException("Bad lane type for casting.");
1342             }
1343         }
1344 
1345         @Override
1346         public Byte128Shuffle rearrange(Vector.Shuffle<Byte> o) {
1347             Byte128Shuffle s = (Byte128Shuffle) o;
1348             byte[] r = new byte[reorder.length];
1349             for (int i = 0; i < reorder.length; i++) {
1350                 r[i] = reorder[s.reorder[i]];
1351             }
1352             return new Byte128Shuffle(r);
1353         }
1354     }
1355 
1356     // Species
1357 
1358     @Override
1359     public Species<Byte> species() {
1360         return SPECIES;
1361     }
1362 }


 801     @Override
 802     @ForceInline
 803     public byte minAll(Mask<Byte> m) {
 804         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, Byte.MAX_VALUE), m).minAll();
 805     }
 806 
 807     @Override
 808     @ForceInline
 809     public byte maxAll(Mask<Byte> m) {
 810         return blend((Byte128Vector)ByteVector.broadcast(SPECIES, Byte.MIN_VALUE), m).maxAll();
 811     }
 812 
 813     @Override
 814     @ForceInline
 815     public Shuffle<Byte> toShuffle() {
 816         byte[] a = toArray();
 817         int[] sa = new int[a.length];
 818         for (int i = 0; i < a.length; i++) {
 819             sa[i] = (int) a[i];
 820         }
 821         return Shuffle.fromArray(SPECIES, sa, 0);
 822     }
 823 
 824     // Memory operations
 825 
 826     private static final int ARRAY_SHIFT         = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BYTE_INDEX_SCALE);
 827     private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE);
 828 
 829     @Override
 830     @ForceInline
 831     public void intoArray(byte[] a, int ix) {
 832         Objects.requireNonNull(a);
 833         ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
 834         VectorIntrinsics.store(Byte128Vector.class, byte.class, LENGTH,
 835                                a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 836                                this,
 837                                a, ix,
 838                                (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
 839     }
 840 
 841     @Override


1262             Byte128Mask m = (Byte128Mask)o;
1263             return VectorIntrinsics.binaryOp(VECTOR_OP_OR, Byte128Mask.class, byte.class, LENGTH,
1264                                              this, m,
1265                                              (m1, m2) -> m1.bOp(m2, (i, a, b) -> a | b));
1266         }
1267 
1268         // Reductions
1269 
1270         @Override
1271         @ForceInline
1272         public boolean anyTrue() {
1273             return VectorIntrinsics.test(BT_ne, Byte128Mask.class, byte.class, LENGTH,
1274                                          this, this,
1275                                          (m, __) -> anyTrueHelper(((Byte128Mask)m).getBits()));
1276         }
1277 
1278         @Override
1279         @ForceInline
1280         public boolean allTrue() {
1281             return VectorIntrinsics.test(BT_overflow, Byte128Mask.class, byte.class, LENGTH,
1282                                          this, Mask.maskAllTrue(species()),
1283                                          (m, __) -> allTrueHelper(((Byte128Mask)m).getBits()));
1284         }
1285     }
1286 
1287     // Shuffle
1288 
1289     static final class Byte128Shuffle extends AbstractShuffle<Byte> {
1290         Byte128Shuffle(byte[] reorder) {
1291             super(reorder);
1292         }
1293 
1294         public Byte128Shuffle(int[] reorder) {
1295             super(reorder);
1296         }
1297 
1298         public Byte128Shuffle(int[] reorder, int i) {
1299             super(reorder, i);
1300         }
1301 
1302         public Byte128Shuffle(IntUnaryOperator f) {


1326             Class<?> stype = species.elementType();
1327             int [] shuffleArray = toArray();
1328             if (stype == byte.class) {
1329                 return (Shuffle<F>) new Byte128Vector.Byte128Shuffle(shuffleArray);
1330             } else if (stype == short.class) {
1331                 return (Shuffle<F>) new Short128Vector.Short128Shuffle(shuffleArray);
1332             } else if (stype == int.class) {
1333                 return (Shuffle<F>) new Int128Vector.Int128Shuffle(shuffleArray);
1334             } else if (stype == long.class) {
1335                 return (Shuffle<F>) new Long128Vector.Long128Shuffle(shuffleArray);
1336             } else if (stype == float.class) {
1337                 return (Shuffle<F>) new Float128Vector.Float128Shuffle(shuffleArray);
1338             } else if (stype == double.class) {
1339                 return (Shuffle<F>) new Double128Vector.Double128Shuffle(shuffleArray);
1340             } else {
1341                 throw new UnsupportedOperationException("Bad lane type for casting.");
1342             }
1343         }
1344 
1345         @Override
1346         public Byte128Shuffle rearrange(Shuffle<Byte> o) {
1347             Byte128Shuffle s = (Byte128Shuffle) o;
1348             byte[] r = new byte[reorder.length];
1349             for (int i = 0; i < reorder.length; i++) {
1350                 r[i] = reorder[s.reorder[i]];
1351             }
1352             return new Byte128Shuffle(r);
1353         }
1354     }
1355 
1356     // Species
1357 
1358     @Override
1359     public Species<Byte> species() {
1360         return SPECIES;
1361     }
1362 }
< prev index next >