1 /*

     2  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 import org.testng.annotations.BeforeClass;

    25 import org.testng.annotations.DataProvider;

    26 

    27 import java.lang.invoke.VarHandle;

    28 import java.nio.ByteBuffer;

    29 import java.nio.ByteOrder;

    30 import java.util.ArrayList;

    31 import java.util.Arrays;

    32 import java.util.EnumSet;

    33 import java.util.List;

    34 import java.util.function.Function;

    35 

    36 public abstract class VarHandleBaseByteArrayTest extends VarHandleBaseTest {

    37 

    38     enum MemoryMode {

    39         ALIGNED(0, false), UNALIGNED(0, true),

    40         BIG_ENDIAN(1, false), LITTLE_ENDIAN(1, true),

    41         READ_WRITE(2, false), READ_ONLY(2, true),;

    42 

    43         final int bit;

    44         final int value;

    45 

    46         MemoryMode(int bit, boolean value) {

    47             this.bit = bit;

    48             this.value = value ? 1 << bit : 0;

    49         }

    50 

    51         boolean isSet(int bitSet) {

    52             return (bitSet & (1 << bit)) == value;

    53         }

    54 

    55         static int bitSet(MemoryMode... modes) {

    56             if (modes == null) return 0;

    57 

    58             int set = 0;

    59             for (MemoryMode m : modes) {

    60                 set = (set & ~(1 << m.bit)) | m.value;

    61             }

    62             return set;

    63         }

    64 

    65         static EnumSet<MemoryMode> enumSet(int bitSet) {

    66             EnumSet<MemoryMode> es = EnumSet.noneOf(MemoryMode.class);

    67             for (MemoryMode m : values()) {

    68                 if (m.isSet(bitSet)) {

    69                     es.add(m);

    70                 }

    71             }

    72             return es;

    73         }

    74     }

    75 

    76     static class Source<T> {

    77         final T s;

    78         final int memoryModes;

    79 

    80         public Source(T s, MemoryMode... modes) {

    81             this.s = s;

    82             memoryModes = MemoryMode.bitSet(modes);

    83         }

    84 

    85         @Override

    86         public String toString() {

    87             return s.getClass().getCanonicalName() + " " + MemoryMode.enumSet(memoryModes);

    88         }

    89     }

    90 

    91     static abstract class ByteArrayViewSource<T> extends Source<T> {

    92         public ByteArrayViewSource(T t, MemoryMode... modes) {

    93             super(t, modes);

    94         }

    95 

    96         abstract void fill(byte value);

    97 

    98         abstract void fill(byte[] values);

    99     }

   100 

   101     static class ByteArraySource extends ByteArrayViewSource<byte[]> {

   102         public ByteArraySource(byte[] bytes, MemoryMode... modes) {

   103             super(bytes, modes);

   104         }

   105 

   106         void fill(byte value) {

   107             Arrays.fill(s, value);

   108         }

   109 

   110         void fill(byte[] values) {

   111             for (int i = 0; i < s.length; i++) {

   112                 s[i] = values[i % values.length];

   113             }

   114         }

   115     }

   116 

   117     static class ByteBufferSource extends ByteArrayViewSource<ByteBuffer> {

   118         public ByteBufferSource(ByteBuffer buffer, MemoryMode... modes) {

   119             super(buffer, modes);

   120         }

   121 

   122         void fill(byte value) {

   123             for (int i = 0; i < s.limit(); i++) {

   124                 s.put(i, value);

   125             }

   126         }

   127 

   128         void fill(byte[] values) {

   129             for (int i = 0; i < s.limit(); i++) {

   130                 s.put(i, values[i % values.length]);

   131             }

   132         }

   133 

   134         @Override

   135         public String toString() {

   136             return s + " " + MemoryMode.enumSet(memoryModes);

   137         }

   138     }

   139 

   140     static class ByteBufferReadOnlySource extends ByteBufferSource {

   141         final ByteBuffer rwSource;

   142 

   143         public ByteBufferReadOnlySource(ByteBuffer roBuffer, ByteBuffer rwSource, MemoryMode... modes) {

   144             super(roBuffer, modes);

   145             this.rwSource = rwSource;

   146         }

   147 

   148         void fill(byte value) {

   149             for (int i = 0; i < rwSource.limit(); i++) {

   150                 rwSource.put(i, value);

   151             }

   152         }

   153 

   154         void fill(byte[] values) {

   155             for (int i = 0; i < rwSource.limit(); i++) {

   156                 rwSource.put(i, values[i % values.length]);

   157             }

   158         }

   159     }

   160 

   161     static class VarHandleSource extends Source<VarHandle> {

   162         VarHandleSource(VarHandle vh, MemoryMode... modes) {

   163             super(vh, modes);

   164         }

   165 

   166         boolean matches(ByteArrayViewSource<?> bav) {

   167             return s.coordinateTypes().get(0).isAssignableFrom(bav.s.getClass());

   168         }

   169 

   170         @Override

   171         public String toString() {

   172             return " VarHandle " + MemoryMode.enumSet(memoryModes);

   173         }

   174     }

   175 

   176     static class VarHandleSourceAccessTestCase extends AccessTestCase<VarHandleSource> {

   177         final ByteArrayViewSource<?> bs;

   178         final VarHandleSource vhs;

   179 

   180         VarHandleSourceAccessTestCase(String desc, ByteArrayViewSource<?> bs, VarHandleSource vhs, AccessTestAction<VarHandleSource> ata) {

   181             this(desc, bs, vhs, ata, true);

   182         }

   183 

   184         VarHandleSourceAccessTestCase(String desc, ByteArrayViewSource<?> bs, VarHandleSource vhs, AccessTestAction<VarHandleSource> ata, boolean loop) {

   185             super(vhs + " -> " + bs + " " + desc, ata, loop);

   186             this.bs = bs;

   187             this.vhs = vhs;

   188         }

   189 

   190         @Override

   191         VarHandleSource get() {

   192             return vhs;

   193         }

   194     }

   195 

   196 

   197     static double rotateLeft(double i, int distance) {

   198         return Double.longBitsToDouble(

   199                 Long.rotateLeft(Double.doubleToRawLongBits(i), distance));

   200     }

   201 

   202     static double rotateRight(double i, int distance) {

   203         return Double.longBitsToDouble(

   204                 Long.rotateRight(Double.doubleToRawLongBits(i), distance));

   205     }

   206 

   207     static float rotateLeft(float i, int distance) {

   208         return Float.intBitsToFloat(

   209                 Integer.rotateLeft(Float.floatToRawIntBits(i), distance));

   210     }

   211 

   212     static float rotateRight(float i, int distance) {

   213         return Float.intBitsToFloat(

   214                 Integer.rotateRight(Float.floatToRawIntBits(i), distance));

   215     }

   216 

   217     static long rotateLeft(long i, int distance) {

   218         return Long.rotateLeft(i, distance);

   219     }

   220 

   221     static long rotateRight(long i, int distance) {

   222         return Long.rotateRight(i, distance);

   223     }

   224 

   225     static int rotateLeft(int i, int distance) {

   226         return Integer.rotateLeft(i, distance);

   227     }

   228 

   229     static int rotateRight(int i, int distance) {

   230         return Integer.rotateRight(i, distance);

   231     }

   232 

   233     static short rotateLeft(short i, int distance) {

   234         int v = (i << 16) | i;

   235         v = Integer.rotateLeft(v, distance);

   236         return (short) v;

   237     }

   238 

   239     static short rotateRight(short i, int distance) {

   240         int v = (i << 16) | i;

   241         v = Integer.rotateRight(v, distance);

   242         return (short) v;

   243     }

   244 

   245     static char rotateLeft(char i, int distance) {

   246         int v = (i << 16) | i;

   247         v = Integer.rotateLeft(v, distance);

   248         return (char) v;

   249     }

   250 

   251     static char rotateRight(char i, int distance) {

   252         int v = (i << 16) | i;

   253         v = Integer.rotateRight(v, distance);

   254         return (char) v;

   255     }

   256 

   257     static final int LENGTH_BYTES = 32;

   258 

   259     byte[] array;

   260 

   261     List<ByteArrayViewSource<?>> bavss;

   262 

   263     List<VarHandleSource> vhss;

   264 

   265     public void setupByteSources() {

   266         array = new byte[LENGTH_BYTES];

   267 

   268         // Native endianess

   269         MemoryMode ne = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN

   270                         ? MemoryMode.BIG_ENDIAN : MemoryMode.LITTLE_ENDIAN;

   271 

   272         bavss = new ArrayList<>();

   273 

   274         // byte[] source

   275         ByteArraySource a =

   276                 new ByteArraySource(array,

   277                                     ne, MemoryMode.READ_WRITE);

   278         bavss.add(a);

   279 

   280 

   281         // Combinations of ByteBuffer sources

   282         ByteBufferSource hbb =

   283                 new ByteBufferSource(ByteBuffer.wrap(array),

   284                                      MemoryMode.ALIGNED, ne, MemoryMode.READ_WRITE);

   285         bavss.add(hbb);

   286         ByteBufferReadOnlySource hbb_ro =

   287                 new ByteBufferReadOnlySource(hbb.s.asReadOnlyBuffer(), hbb.s,

   288                                              MemoryMode.ALIGNED, ne, MemoryMode.READ_ONLY);

   289         bavss.add(hbb_ro);

   290 

   291         ByteBufferSource hbb_offset_aligned =

   292                 new ByteBufferSource(ByteBuffer.wrap(array, array.length / 4, array.length / 2).slice(),

   293                                      MemoryMode.ALIGNED, ne, MemoryMode.READ_WRITE);

   294         bavss.add(hbb_offset_aligned);

   295         ByteBufferReadOnlySource hbb_offset_aligned_ro =

   296                 new ByteBufferReadOnlySource(hbb_offset_aligned.s.asReadOnlyBuffer(), hbb_offset_aligned.s,

   297                                              MemoryMode.ALIGNED, ne, MemoryMode.READ_ONLY);

   298         bavss.add(hbb_offset_aligned_ro);

   299 

   300         ByteBufferSource hbb_offset_unaligned =

   301                 new ByteBufferSource(ByteBuffer.wrap(array, array.length / 4 - 1, array.length / 2).slice(),

   302                                      MemoryMode.UNALIGNED, ne, MemoryMode.READ_WRITE);

   303         bavss.add(hbb_offset_unaligned);

   304         ByteBufferReadOnlySource hbb_offset_unaligned_ro =

   305                 new ByteBufferReadOnlySource(hbb_offset_unaligned.s.asReadOnlyBuffer(), hbb_offset_unaligned.s,

   306                                              MemoryMode.UNALIGNED, ne, MemoryMode.READ_ONLY);

   307         bavss.add(hbb_offset_unaligned_ro);

   308 

   309 

   310         ByteBufferSource dbb =

   311                 new ByteBufferSource(ByteBuffer.allocateDirect(array.length),

   312                                      MemoryMode.ALIGNED, ne, MemoryMode.READ_WRITE);

   313         bavss.add(dbb);

   314         ByteBufferReadOnlySource dbb_ro =

   315                 new ByteBufferReadOnlySource(dbb.s.asReadOnlyBuffer(), dbb.s,

   316                                              MemoryMode.ALIGNED, ne, MemoryMode.READ_ONLY);

   317         bavss.add(dbb_ro);

   318 

   319         ByteBufferSource dbb_offset_aligned =

   320                 new ByteBufferSource(dbb.s.slice().position(array.length / 4).limit(array.length / 4 + array.length / 2).slice(),

   321                                      MemoryMode.ALIGNED, ne, MemoryMode.READ_WRITE);

   322         bavss.add(dbb_offset_aligned);

   323         ByteBufferReadOnlySource dbb_offset_aligned_ro =

   324                 new ByteBufferReadOnlySource(dbb_offset_aligned.s.asReadOnlyBuffer(), dbb_offset_aligned.s,

   325                                              MemoryMode.ALIGNED, ne, MemoryMode.READ_ONLY);

   326         bavss.add(dbb_offset_aligned_ro);

   327 

   328         ByteBufferSource dbb_offset_unaligned =

   329                 new ByteBufferSource(dbb.s.slice().position(array.length / 4 - 1).limit(array.length / 4 - 1 + array.length / 2).slice(),

   330                                      MemoryMode.UNALIGNED, ne, MemoryMode.READ_WRITE);

   331         bavss.add(dbb_offset_unaligned);

   332         ByteBufferReadOnlySource dbb_offset_unaligned_ro =

   333                 new ByteBufferReadOnlySource(dbb_offset_unaligned.s.asReadOnlyBuffer(), dbb_offset_unaligned.s,

   334                                              MemoryMode.UNALIGNED, ne, MemoryMode.READ_ONLY);

   335         bavss.add(dbb_offset_unaligned_ro);

   336     }

   337 

   338     @BeforeClass

   339     public void setup() {

   340         setupByteSources();

   341         setupVarHandleSources();

   342     }

   343 

   344     abstract void setupVarHandleSources();

   345 

   346 

   347     @DataProvider

   348     public Object[][] varHandlesProvider() throws Exception {

   349         return vhss.stream().map(cvh -> new Object[]{cvh}).toArray(Object[][]::new);

   350     }

   351 

   352     @DataProvider

   353     public Object[][] typesProvider() throws Exception {

   354         List<java.lang.Class<?>> aepts = Arrays.asList(byte[].class, int.class);

   355         List<java.lang.Class<?>> bbpts = Arrays.asList(ByteBuffer.class, int.class);

   356 

   357         Function<VarHandle, List<Class<?>>> vhToPts = vh ->

   358                 vh.coordinateTypes().get(0) == byte[].class ? aepts : bbpts;

   359 

   360         return vhss.stream().map(vh -> new Object[]{vh.s, vhToPts.apply(vh.s)}).toArray(Object[][]::new);

   361     }

   362 }