1 //

     2 // Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.

     3 // Copyright (c) 2015, Red Hat Inc. All rights reserved.

     4 // DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5 //

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

     7 // under the terms of the GNU General Public License version 2 only, as

     8 // published by the Free Software Foundation.

     9 //

    10 // This code is distributed in the hope that it will be useful, but WITHOUT

    11 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13 // version 2 for more details (a copy is included in the LICENSE file that

    14 // accompanied this code).

    15 //

    16 // You should have received a copy of the GNU General Public License version

    17 // 2 along with this work; if not, write to the Free Software Foundation,

    18 // Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19 //

    20 // Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21 // or visit www.oracle.com if you need additional information or have any

    22 // questions.

    23 //

    24 //

    25 

    26 

    27 import static java.lang.Math.abs;

    28 import java.nio.ByteBuffer;

    29 import java.nio.ByteOrder;

    30 import static java.nio.ByteOrder.BIG_ENDIAN;

    31 import static java.nio.ByteOrder.LITTLE_ENDIAN;

    32 import java.util.SplittableRandom;

    33 import java.util.Arrays;

    34 

    35 /**

    36  * @test

    37  * @bug 8026049

    38  * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:-UseUnalignedAccesses HeapByteBufferTest

    39  * @run main/othervm HeapByteBufferTest

    40  * @summary Verify that byte buffers are correctly accessed.

    41  */

    42 

    43 // A wrapper for a ByteBuffer which maintains a backing array and a

    44 // position.  Whenever this wrapper is written the backing array and

    45 // the wrapped byte buffer are updated together, and whenever it is

    46 // read we check that the ByteBuffer and the backing array are identical.

    47 

    48 class MyByteBuffer {

    49     final ByteBuffer buf;

    50     final byte[] bytes;

    51     int pos;

    52     ByteOrder byteOrder = BIG_ENDIAN;

    53 

    54     MyByteBuffer(ByteBuffer buf, byte[] bytes) {

    55         this.buf = buf;

    56         this.bytes = Arrays.copyOf(bytes, bytes.length);

    57         pos = 0;

    58     }

    59 

    60     public final MyByteBuffer order(ByteOrder bo) {

    61         byteOrder = bo;

    62         buf.order(bo);

    63         return this;

    64     }

    65 

    66     static MyByteBuffer wrap(byte[] bytes) {

    67         return new MyByteBuffer(ByteBuffer.wrap(bytes), bytes);

    68     }

    69 

    70     int capacity() { return bytes.length; }

    71     int position() {

    72         if (buf.position() != pos)

    73             throw new RuntimeException();

    74         return buf.position();

    75     }

    76 

    77     byte[] array() { return buf.array(); }

    78     byte[] backingArray() { return bytes; }

    79 

    80     private static byte long7(long x) { return (byte)(x >> 56); }

    81     private static byte long6(long x) { return (byte)(x >> 48); }

    82     private static byte long5(long x) { return (byte)(x >> 40); }

    83     private static byte long4(long x) { return (byte)(x >> 32); }

    84     private static byte long3(long x) { return (byte)(x >> 24); }

    85     private static byte long2(long x) { return (byte)(x >> 16); }

    86     private static byte long1(long x) { return (byte)(x >>  8); }

    87     private static byte long0(long x) { return (byte)(x      ); }

    88 

    89     private static byte int3(int x) { return (byte)(x >> 24); }

    90     private static byte int2(int x) { return (byte)(x >> 16); }

    91     private static byte int1(int x) { return (byte)(x >>  8); }

    92     private static byte int0(int x) { return (byte)(x      ); }

    93 

    94     private static byte short1(short x) { return (byte)(x >> 8); }

    95     private static byte short0(short x) { return (byte)(x     ); }

    96 

    97     byte _get(long i) { return bytes[(int)i]; }

    98     void _put(long i, byte x) { bytes[(int)i] = x; }

    99 

   100     private void putLongX(long a, long x) {

   101         if (byteOrder == BIG_ENDIAN) {

   102             x = Long.reverseBytes(x);

   103         }

   104         _put(a + 7, long7(x));

   105         _put(a + 6, long6(x));

   106         _put(a + 5, long5(x));

   107         _put(a + 4, long4(x));

   108         _put(a + 3, long3(x));

   109         _put(a + 2, long2(x));

   110         _put(a + 1, long1(x));

   111         _put(a    , long0(x));

   112     }

   113 

   114     private void putIntX(long a, int x) {

   115         if (byteOrder == BIG_ENDIAN) {

   116             x = Integer.reverseBytes(x);

   117         }

   118         _put(a + 3, int3(x));

   119         _put(a + 2, int2(x));

   120         _put(a + 1, int1(x));

   121         _put(a    , int0(x));

   122     }

   123 

   124     private void putShortX(int bi, short x) {

   125         if (byteOrder == BIG_ENDIAN) {

   126             x = Short.reverseBytes(x);

   127         }

   128         _put(bi    , short0(x));

   129         _put(bi + 1, short1(x));

   130     }

   131 

   132     static private int makeInt(byte b3, byte b2, byte b1, byte b0) {

   133         return (((b3       ) << 24) |

   134                 ((b2 & 0xff) << 16) |

   135                 ((b1 & 0xff) <<  8) |

   136                 ((b0 & 0xff)      ));

   137     }

   138     int getIntX(long a) {

   139         int x = makeInt(_get(a + 3),

   140                 _get(a + 2),

   141                 _get(a + 1),

   142                 _get(a));

   143         if (byteOrder == BIG_ENDIAN) {

   144             x = Integer.reverseBytes(x);

   145         }

   146         return x;

   147     }

   148 

   149     static private long makeLong(byte b7, byte b6, byte b5, byte b4,

   150                                  byte b3, byte b2, byte b1, byte b0)

   151     {

   152         return ((((long)b7       ) << 56) |

   153                 (((long)b6 & 0xff) << 48) |

   154                 (((long)b5 & 0xff) << 40) |

   155                 (((long)b4 & 0xff) << 32) |

   156                 (((long)b3 & 0xff) << 24) |

   157                 (((long)b2 & 0xff) << 16) |

   158                 (((long)b1 & 0xff) <<  8) |

   159                 (((long)b0 & 0xff)      ));

   160     }

   161 

   162     long getLongX(long a) {

   163         long x = makeLong(_get(a + 7),

   164                 _get(a + 6),

   165                 _get(a + 5),

   166                 _get(a + 4),

   167                 _get(a + 3),

   168                 _get(a + 2),

   169                 _get(a + 1),

   170                 _get(a));

   171         if (byteOrder == BIG_ENDIAN) {

   172             x = Long.reverseBytes(x);

   173         }

   174         return x;

   175     }

   176 

   177     static private short makeShort(byte b1, byte b0) {

   178         return (short)((b1 << 8) | (b0 & 0xff));

   179     }

   180 

   181     short getShortX(long a) {

   182         short x = makeShort(_get(a + 1),

   183                             _get(a    ));

   184         if (byteOrder == BIG_ENDIAN) {

   185             x = Short.reverseBytes(x);

   186         }

   187         return x;

   188     }

   189 

   190     double getDoubleX(long a) {

   191         long x = getLongX(a);

   192         return Double.longBitsToDouble(x);

   193     }

   194 

   195     double getFloatX(long a) {

   196         int x = getIntX(a);

   197         return Float.intBitsToFloat(x);

   198     }

   199 

   200     void ck(long x, long y) {

   201         if (x != y) {

   202             throw new RuntimeException(" x = " + Long.toHexString(x) + ", y = " + Long.toHexString(y));

   203         }

   204     }

   205 

   206     void ck(double x, double y) {

   207         if (x == x && y == y && x != y) {

   208             ck(x, y);

   209         }

   210     }

   211 

   212     long getLong(int i) { ck(buf.getLong(i), getLongX(i)); return buf.getLong(i); }

   213     int getInt(int i) { ck(buf.getInt(i), getIntX(i)); return buf.getInt(i); }

   214     short getShort(int i) { ck(buf.getShort(i), getShortX(i)); return buf.getShort(i); }

   215     char getChar(int i) { ck(buf.getChar(i), (char)getShortX(i)); return buf.getChar(i); }

   216     double getDouble(int i) { ck(buf.getDouble(i), getDoubleX(i)); return buf.getDouble(i); }

   217     float getFloat(int i) { ck(buf.getFloat(i), getFloatX(i)); return buf.getFloat(i); }

   218 

   219     void putLong(int i, long x) { buf.putLong(i, x); putLongX(i, x); }

   220     void putInt(int i, int x) { buf.putInt(i, x); putIntX(i, x); }

   221     void putShort(int i, short x) { buf.putShort(i, x); putShortX(i, x); }

   222     void putChar(int i, char x) { buf.putChar(i, x); putShortX(i, (short)x); }

   223     void putDouble(int i, double x) { buf.putDouble(i, x); putLongX(i, Double.doubleToRawLongBits(x)); }

   224     void putFloat(int i, float x) { buf.putFloat(i, x); putIntX(i, Float.floatToRawIntBits(x)); }

   225 

   226     long getLong() { ck(buf.getLong(buf.position()), getLongX(pos)); long x = buf.getLong(); pos += 8; return x; }

   227     int getInt() { ck(buf.getInt(buf.position()), getIntX(pos)); int x = buf.getInt(); pos += 4; return x; }

   228     short getShort() { ck(buf.getShort(buf.position()), getShortX(pos)); short x = buf.getShort(); pos += 2; return x; }

   229     char getChar() {  ck(buf.getChar(buf.position()), (char)getShortX(pos)); char x = buf.getChar(); pos += 2; return x; }

   230     double getDouble() { ck(buf.getDouble(buf.position()), getDoubleX(pos)); double x = buf.getDouble(); pos += 8; return x; }

   231     float getFloat() { ck(buf.getFloat(buf.position()), getFloatX(pos)); float x = buf.getFloat(); pos += 4; return x; }

   232 

   233     void putLong(long x) { putLongX(pos, x); pos += 8; buf.putLong(x); }

   234     void putInt(int x) { putIntX(pos, x); pos += 4; buf.putInt(x); }

   235     void putShort(short x) { putShortX(pos, x); pos += 2; buf.putShort(x); }

   236     void putChar(char x) { putShortX(pos, (short)x); pos += 2; buf.putChar(x); }

   237     void putDouble(double x) { putLongX(pos, Double.doubleToRawLongBits(x)); pos += 8; buf.putDouble(x); }

   238     void putFloat(float x) { putIntX(pos, Float.floatToRawIntBits(x)); pos += 4; buf.putFloat(x); }

   239 

   240     void rewind() { pos = 0; buf.rewind(); }

   241 }

   242 

   243 public class HeapByteBufferTest implements Runnable {

   244 

   245     SplittableRandom random = new SplittableRandom();

   246     MyByteBuffer data = MyByteBuffer.wrap(new byte[1024]);

   247 

   248     int randomOffset(SplittableRandom r, MyByteBuffer buf, int size) {

   249         return abs(r.nextInt()) % (buf.capacity() - size);

   250     }

   251 

   252     long iterations;

   253 

   254     HeapByteBufferTest(long iterations) {

   255         this.iterations = iterations;

   256     }

   257 

   258     // The core of the test.  Walk over the buffer reading and writing

   259     // random data, XORing it as we go.  We can detect writes in the

   260     // wrong place, writes which are too long or too short, and reads

   261     // or writes of the wrong data,

   262     void step(SplittableRandom r) {

   263         data.order((r.nextInt() & 1) != 0 ? BIG_ENDIAN : LITTLE_ENDIAN);

   264 

   265         data.rewind();

   266         while (data.position() < data.capacity())

   267             data.putLong(data.getLong() ^ random.nextLong());

   268 

   269         data.rewind();

   270         while (data.position() < data.capacity())

   271             data.putInt(data.getInt() ^ random.nextInt());

   272 

   273         data.rewind();

   274         while (data.position() < data.capacity())

   275             data.putShort((short)(data.getShort() ^ random.nextInt()));

   276 

   277         data.rewind();

   278         while (data.position() < data.capacity())

   279             data.putChar((char)(data.getChar() ^ random.nextInt()));

   280 

   281         data.rewind();

   282         while (data.position() < data.capacity()) {

   283             data.putDouble(combine(data.getDouble(), random.nextLong()));

   284         }

   285 

   286         data.rewind();

   287         while (data.position() < data.capacity())

   288             data.putFloat(combine(data.getFloat(), random.nextInt()));

   289 

   290         for (int i = 0; i < 100; i++) {

   291             int offset = randomOffset(r, data, 8);

   292             data.putLong(offset, data.getLong(offset) ^ random.nextLong());

   293         }

   294         for (int i = 0; i < 100; i++) {

   295             int offset = randomOffset(r, data, 4);

   296             data.putInt(offset, data.getInt(offset) ^ random.nextInt());

   297         }

   298         for (int i = 0; i < 100; i++) {

   299             int offset = randomOffset(r, data, 4);

   300             data.putShort(offset, (short)(data.getShort(offset) ^ random.nextInt()));

   301         }

   302         for (int i = 0; i < 100; i++) {

   303             int offset = randomOffset(r, data, 4);

   304             data.putChar(offset, (char)(data.getChar(offset) ^ random.nextInt()));

   305         }

   306         for (int i = 0; i < 100; i++) {

   307             int offset = randomOffset(r, data, 8);

   308             data.putDouble(offset, combine(data.getDouble(offset), random.nextLong()));

   309         }

   310         for (int i = 0; i < 100; i++) {

   311             int offset = randomOffset(r, data, 4);

   312             data.putFloat(offset, combine(data.getFloat(offset), random.nextInt()));

   313         }

   314     }

   315 

   316     // XOR the bit pattern of a double and a long, returning the

   317     // result as a double.

   318     //

   319     // We convert signalling NaNs to quiet NaNs.  We need to do this

   320     // because some platforms (in particular legacy 80x87) do not

   321     // provide transparent conversions between integer and

   322     // floating-point types even when using raw conversions but

   323     // quietly convert sNaN to qNaN.  This causes spurious test

   324     // failures when the template interpreter uses 80x87 and the JITs

   325     // use XMM registers.

   326     //

   327     public double combine(double prev, long bits) {

   328         bits ^= Double.doubleToRawLongBits(prev);

   329         double result = Double.longBitsToDouble(bits);

   330         if (Double.isNaN(result)) {

   331             result = Double.longBitsToDouble(bits | 0x8000000000000l);

   332         }

   333         return result;

   334     }

   335 

   336     // XOR the bit pattern of a float and an int, returning the result

   337     // as a float.  Convert sNaNs to qNaNs.

   338     public Float combine(float prev, int bits) {

   339         bits ^= Float.floatToRawIntBits(prev);

   340         Float result = Float.intBitsToFloat(bits);

   341         if (Float.isNaN(result)) {

   342             result = Float.intBitsToFloat(bits | 0x400000);

   343         }

   344         return result;

   345     }

   346 

   347     public void run() {

   348         SplittableRandom r = new SplittableRandom();

   349 

   350         for (int i = 0; i < data.capacity(); i += 8) {

   351             data.putLong(i, random.nextLong());

   352         }

   353 

   354         for (int i = 0; i < iterations; i++) {

   355             step(r);

   356         }

   357 

   358         if (!Arrays.equals(data.array(), data.backingArray())) {

   359             throw new RuntimeException();

   360         }

   361     }

   362 

   363     public static void main(String[] args) {

   364         // The number of iterations is high to ensure that tiered

   365         // compilation kicks in all the way up to C2.

   366         long iterations = 100000;

   367         if (args.length > 0)

   368             iterations = Long.parseLong(args[0]);

   369 

   370         new HeapByteBufferTest(iterations).run();

   371     }

   372 }