Converting bytes to shorts using arrays and NIO buffers - is this a bug?

Question

I'm benchmarking the various methods for converting a sequence of bytes into shorts. I tried copying a byte array, a direct NIO buffer and a non-direct NIO buffer to a short array (using little-endian byte order). My results were a little confusing to me. As I understand it, direct buffers are basically native buffers - allocated by the OS instead of on the runtime's managed heap, hence their higher allocation cost and ability to perform quicker IO with channels that can use them directly. I also got the impression that non-direct buffers (which have a backing array) are basically just regular Java arrays wrapped in a ByteBuffer.
I didn't expect a huge difference between the results of my three tests, though I thought the two NIO methods might perform a bit quicker if the virtual machine was smart enough to notice that little-endian is my system's native byte order (hence allowing the chunk of memory to simply be copied, rather than applying a bunch of shifts and ORs to the bytes). Conversion with the direct NIO buffer was indeed faster than my byte array method, however the non-direct NIO buffer performed over ten times slower than even my array method. I can see it maybe performing a millisecond or two slower than the array method, what with virtual function call overhead and a few if checks to see what byte order should be used and what not, but shouldn't that method basically be doing exactly the same thing as my array method? Why is it so horribly slow?
Snippet:
import java.nio.*;
public class Program {
  public static final int LOOPS = 500;
  public static final int BUFFER_SIZE = 1024 * 1024;
  public static void copyByteArrayToShortArrayLE(byte[] buffer8, short[] buffer16) {
    for(int i = 0; i < buffer16.length; i += 2){
      buffer16[i >>> 1] = (short) ((buffer8[i] & 0xff) | ((buffer8[i + 1] & 0xff) << 8));
  public static void main(String[] args) {
    short[] shorts = new short[BUFFER_SIZE >>> 1];
    byte[] arrayBuffer = new byte[BUFFER_SIZE];
    ByteBuffer directBuffer = ByteBuffer.allocateDirect(BUFFER_SIZE).order(ByteOrder.LITTLE_ENDIAN);
    ByteBuffer nonDirectBuffer = ByteBuffer.allocate(BUFFER_SIZE).order(ByteOrder.LITTLE_ENDIAN);
    long start;
    start = System.currentTimeMillis();
    for(int i = 0; i < LOOPS; ++i) copyByteArrayToShortArrayLE(arrayBuffer, shorts);
    long timeArray = System.currentTimeMillis() - start;
    start = System.currentTimeMillis();
    for(int i = 0; i < LOOPS; ++i) directBuffer.asShortBuffer().get(shorts);
    long timeDirect = System.currentTimeMillis() - start;
    start = System.currentTimeMillis();
    for(int i = 0; i < LOOPS; ++i) nonDirectBuffer.asShortBuffer().get(shorts);
    long timeNonDirect = System.currentTimeMillis() - start;
    System.out.println("Array:      " + timeArray);
    System.out.println("Direct:     " + timeDirect);
    System.out.println("Non-direct: " + timeNonDirect);
}Result:
Array:      328
Direct:     234
Non-direct: 4860

Answer 1

Using JDK1.6.0_18 on Ubuntu 9.1 I typically get
Array: 396
Direct: 550
Non-direct: 789
I think your tests are a little too short for accurate timings because they are likely to be significantly influenced by the JIT compilation.
If I change to use a GIT warmup i.e.
public static final int LOOPS = 500;
    public static final int WARMUP_LOOPS = 500;
    public static final int BUFFER_SIZE = 1024 * 1024;
    public static void copyByteArrayToShortArrayLE(byte[] buffer8, short[] buffer16)
        for (int i = 0; i < buffer16.length; i += 2)
            buffer16[i >>> 1] = (short) ((buffer8[i] & 0xff) | ((buffer8[i + 1] & 0xff) << 8));
    public static void main(String[] args)
        short[] shorts = new short[BUFFER_SIZE >>> 1];
        byte[] arrayBuffer = new byte[BUFFER_SIZE];
        ByteBuffer directBuffer = ByteBuffer.allocateDirect(BUFFER_SIZE).order(ByteOrder.LITTLE_ENDIAN);
        ByteBuffer nonDirectBuffer = ByteBuffer.allocate(BUFFER_SIZE).order(ByteOrder.LITTLE_ENDIAN);
        long start = 0;
        for (int i = -WARMUP_LOOPS; i < LOOPS; ++i)
            if (i == 0)
                start = System.currentTimeMillis();
            copyByteArrayToShortArrayLE(arrayBuffer, shorts);
        long timeArray = System.currentTimeMillis() - start;
        for (int i = -WARMUP_LOOPS; i < LOOPS; ++i)
            if (i == 0)
                start = System.currentTimeMillis();
            directBuffer.asShortBuffer().get(shorts);
        long timeDirect = System.currentTimeMillis() - start;
        for (int i = -WARMUP_LOOPS; i < LOOPS; ++i)
            if (i == 0)
                start = System.currentTimeMillis();
            nonDirectBuffer.asShortBuffer().get(shorts);
        long timeNonDirect = System.currentTimeMillis() - start;
        System.out.println("Array:      " + timeArray);
        System.out.println("Direct:     " + timeDirect);
        System.out.println("Non-direct: " + timeNonDirect);
    }then I typically get
Array: 365
Direct: 528
Non-direct: 750
and if I change to 50,000 loops I typically get
Array: 37511
Direct: 57199
Non-direct: 73913
You also seem to have a bug in your copyByteArrayToShortArrayLE() method. Should it not be
public static void copyByteArrayToShortArrayLE(byte[] buffer8, short[] buffer16)
        for (int i = 0; i < buffer8.length; i += 2)
            buffer16[i >>> 1] = (short) ((buffer8[i] & 0xff) | ((buffer8[i + 1] & 0xff) << 8));
    }Edited by: sabre150 on Jan 27, 2010 9:07 AM