< prev index next >

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

Print this page
rev 55589 : 8221816: [vector] IndexOutOfBoundsException for fromArray/intoArray with unset mask lanes
Reviewed-by: duke


 920     @Override
 921     @ForceInline
 922     public Shuffle<Double> toShuffle() {
 923         double[] a = toArray();
 924         int[] sa = new int[a.length];
 925         for (int i = 0; i < a.length; i++) {
 926             sa[i] = (int) a[i];
 927         }
 928         return DoubleVector.shuffleFromArray(SPECIES, sa, 0);
 929     }
 930 
 931     // Memory operations
 932 
 933     private static final int ARRAY_SHIFT         = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_DOUBLE_INDEX_SCALE);
 934     private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE);
 935 
 936     @Override
 937     @ForceInline
 938     public void intoArray(double[] a, int ix) {
 939         Objects.requireNonNull(a);
 940         ix = VectorIntrinsics.checkIndex(ix, a.length, LENGTH);
 941         VectorIntrinsics.store(Double64Vector.class, double.class, LENGTH,
 942                                a, (((long) ix) << ARRAY_SHIFT) + Unsafe.ARRAY_DOUBLE_BASE_OFFSET,
 943                                this,
 944                                a, ix,
 945                                (arr, idx, v) -> v.forEach((i, e) -> arr[idx + i] = e));
 946     }
 947 
 948     @Override
 949     @ForceInline
 950     public final void intoArray(double[] a, int ax, Mask<Double> m) {
 951         DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax);
 952         DoubleVector newVal = oldVal.blend(this, m);
 953         newVal.intoArray(a, ax);
 954     }

 955     @Override
 956     @ForceInline
 957     public void intoArray(double[] a, int ix, int[] b, int iy) {
 958         this.intoArray(a, ix + b[iy]);
 959     }
 960 
 961      @Override
 962      @ForceInline
 963      public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
 964          // @@@ This can result in out of bounds errors for unset mask lanes
 965          DoubleVector oldVal = DoubleVector.fromArray(SPECIES, a, ax, b, iy);
 966          DoubleVector newVal = oldVal.blend(this, m);
 967          newVal.intoArray(a, ax, b, iy);
 968      }
 969 
 970     @Override
 971     @ForceInline
 972     public void intoByteArray(byte[] a, int ix) {
 973         Objects.requireNonNull(a);
 974         ix = VectorIntrinsics.checkIndex(ix, a.length, bitSize() / Byte.SIZE);
 975         VectorIntrinsics.store(Double64Vector.class, double.class, LENGTH,
 976                                a, ((long) ix) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 977                                this,
 978                                a, ix,
 979                                (c, idx, v) -> {
 980                                    ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder());
 981                                    DoubleBuffer tb = bbc.asDoubleBuffer();
 982                                    v.forEach((i, e) -> tb.put(e));
 983                                });
 984     }
 985 
 986     @Override
 987     @ForceInline




 920     @Override
 921     @ForceInline
 922     public Shuffle<Double> toShuffle() {
 923         double[] a = toArray();
 924         int[] sa = new int[a.length];
 925         for (int i = 0; i < a.length; i++) {
 926             sa[i] = (int) a[i];
 927         }
 928         return DoubleVector.shuffleFromArray(SPECIES, sa, 0);
 929     }
 930 
 931     // Memory operations
 932 
 933     private static final int ARRAY_SHIFT         = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_DOUBLE_INDEX_SCALE);
 934     private static final int BOOLEAN_ARRAY_SHIFT = 31 - Integer.numberOfLeadingZeros(Unsafe.ARRAY_BOOLEAN_INDEX_SCALE);
 935 
 936     @Override
 937     @ForceInline
 938     public void intoArray(double[] a, int ix) {
 939         Objects.requireNonNull(a);
 940         forEach((i, e) -> a[ix + i] = e);





 941     }
 942 
 943     @Override
 944     @ForceInline
 945     public final void intoArray(double[] a, int ax, Mask<Double> m) {
 946         Objects.requireNonNull(a);
 947         forEach(m, (i, e) -> a[ax + i] = e);

 948     }
 949 
 950     @Override
 951     @ForceInline
 952     public void intoArray(double[] a, int ix, int[] b, int iy) {
 953         this.intoArray(a, ix + b[iy]);
 954     }
 955 
 956     @Override
 957     @ForceInline
 958     public final void intoArray(double[] a, int ax, Mask<Double> m, int[] b, int iy) {
 959         Objects.requireNonNull(a);
 960         Objects.requireNonNull(b);
 961         forEach(m, (i, e) -> a[ax + b[iy+i]] = e);

 962     }
 963 
 964     @Override
 965     @ForceInline
 966     public void intoByteArray(byte[] a, int ix) {
 967         Objects.requireNonNull(a);
 968         ix = VectorIntrinsics.checkIndex(ix, a.length, bitSize() / Byte.SIZE);
 969         VectorIntrinsics.store(Double64Vector.class, double.class, LENGTH,
 970                                a, ((long) ix) + Unsafe.ARRAY_BYTE_BASE_OFFSET,
 971                                this,
 972                                a, ix,
 973                                (c, idx, v) -> {
 974                                    ByteBuffer bbc = ByteBuffer.wrap(c, idx, c.length - idx).order(ByteOrder.nativeOrder());
 975                                    DoubleBuffer tb = bbc.asDoubleBuffer();
 976                                    v.forEach((i, e) -> tb.put(e));
 977                                });
 978     }
 979 
 980     @Override
 981     @ForceInline


< prev index next >