UUID creation performance

[Brett Okken]

Is there any interest in updating the static UUID.randomUUID() and
UUID.nameUUIDFromBytes(byte[]) factory methods to use either a
ByteBuffer or byteArrayViewVarHandle to convert the byte[] to 2 long
values then do the bit twiddling?
These methods are really dominated by time to create/populate the
byte[], but this does reduce the time to create the 2 long values by
at least half.
It would also allow the removal of the private UUID(byte[] data).

    public static UUID randomUUID() {
        SecureRandom ng = Holder.numberGenerator;

        byte[] randomBytes = new byte[16];
        ng.nextBytes(randomBytes);
        final ByteBuffer bb = ByteBuffer.wrap(randomBytes);
        bb.order(ByteOrder.nativeOrder());

        long msb = bb.getLong();
        long lsb = bb.getLong();

        msb &= 0xFFFFFFFFFFFF0FFFL;  /* clear version        */
        msb |= 0x4000L;              /* set to version 4     */

        lsb &= 0x3FFFFFFFFFFFFFFFL;  /* clear variant        */
        lsb |= 0x8000000000000000L;  /* set to IETF variant  */

        return new UUID(msb, lsb);
    }

    public static UUID nameUUIDFromBytes(byte[] name) {
        MessageDigest md;
        try {
            md = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException nsae) {
            throw new InternalError("MD5 not supported", nsae);
        }
        byte[] md5Bytes = md.digest(name);

        // default byte order is BIG_ENDIAN
        final ByteBuffer bb = ByteBuffer.wrap(md5Bytes);

        long msb = bb.getLong();
        long lsb = bb.getLong();

        msb &= 0xFFFFFFFFFFFF0FFFL;  /* clear version        */
        msb |= 0x3000L;              /* set to version 3     */

        lsb &= 0x3FFFFFFFFFFFFFFFL;  /* clear variant        */
        lsb |= 0x8000000000000000L;  /* set to IETF variant  */

        return new UUID(msb, lsb);
    }

Benchmark                    Mode  Cnt   Score   Error  Units
UUIDBenchmark.jdk_name       avgt    3  11.885 ± 4.025  ns/op
UUIDBenchmark.jdk_random     avgt    3  11.656 ± 0.987  ns/op
UUIDBenchmark.longs          avgt    3   7.618 ± 1.047  ns/op
UUIDBenchmark.longs_bb       avgt    3   7.755 ± 1.643  ns/op
UUIDBenchmark.longs_name     avgt    3   8.467 ± 1.784  ns/op
UUIDBenchmark.longs_name_bb  avgt    3   8.455 ± 1.662  ns/op
UUIDBenchmark.randomBytes    avgt    3   6.132 ± 0.447  ns/op


@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 3, time = 2, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 3, time = 2, timeUnit = TimeUnit.SECONDS)
@Fork(1)
@State(Scope.Benchmark)
public class UUIDBenchmark {

    private static final VarHandle LONGS_ACCESS =
MethodHandles.byteArrayViewVarHandle(long[].class,
ByteOrder.nativeOrder());

    private static final VarHandle BE_LONGS_ACCESS =
MethodHandles.byteArrayViewVarHandle(long[].class,
ByteOrder.BIG_ENDIAN);

    @Benchmark
    public byte[] randomBytes() {
        final byte[] bytes = new byte[16];
        randomBytes(bytes);
        return bytes;
    }

    @Benchmark
    public void jdk_random(Blackhole bh) {
        final byte[] data = new byte[16];
        randomBytes(data);
        data[6]  &= 0x0f;  /* clear version        */
        data[6]  |= 0x40;  /* set to version 4     */
        data[8]  &= 0x3f;  /* clear variant        */
        data[8]  |= 0x80;  /* set to IETF variant  */
        long msb = 0;
        long lsb = 0;
        assert data.length == 16 : "data must be 16 bytes in length";
        for (int i=0; i<8; i++)
            msb = (msb << 8) | (data[i] & 0xff);
        for (int i=8; i<16; i++)
            lsb = (lsb << 8) | (data[i] & 0xff);
        bh.consume(msb);
        bh.consume(lsb);
    }

    @Benchmark
    public void jdk_name(Blackhole bh)
    {
        final byte[] md5Bytes = new byte[16];
        randomBytes(md5Bytes);
        md5Bytes[6]  &= 0x0f;  /* clear version        */
        md5Bytes[6]  |= 0x30;  /* set to version 3     */
        md5Bytes[8]  &= 0x3f;  /* clear variant        */
        md5Bytes[8]  |= 0x80;  /* set to IETF variant  */
        long msb = 0;
        long lsb = 0;
        assert md5Bytes.length == 16 : "data must be 16 bytes in length";
        for (int i=0; i<8; i++)
            msb = (msb << 8) | (md5Bytes[i] & 0xff);
        for (int i=8; i<16; i++)
            lsb = (lsb << 8) | (md5Bytes[i] & 0xff);
        bh.consume(msb);
        bh.consume(lsb);
    }

    @Benchmark
    public void longs(Blackhole bh) {
        final byte[] data = new byte[16];
        randomBytes(data);

        long msb = (long) LONGS_ACCESS.get(data, 0);
        long lsb = (long) LONGS_ACCESS.get(data, 8);

        msb &= 0xFFFFFFFFFFFF0FFFL;
        msb |= 0x4000L;

        lsb &= 0x3FFFFFFFFFFFFFFFL;
        lsb |= 0x8000000000000000L;

        bh.consume(msb);
        bh.consume(lsb);
    }

    @Benchmark
    public void longs_name(Blackhole bh) {
        final byte[] data = new byte[16];
        randomBytes(data);

        long msb = (long) BE_LONGS_ACCESS.get(data, 0);
        long lsb = (long) BE_LONGS_ACCESS.get(data, 8);

        msb &= 0xFFFFFFFFFFFF0FFFL;
        msb |= 0x3000L;

        lsb &= 0x3FFFFFFFFFFFFFFFL;
        lsb |= 0x8000000000000000L;

        bh.consume(msb);
        bh.consume(lsb);
    }

    @Benchmark
    public void longs_bb(Blackhole bh) {
        final byte[] data = new byte[16];
        randomBytes(data);

        final ByteBuffer bb = ByteBuffer.wrap(data);
        bb.order(ByteOrder.nativeOrder());

        long msb = bb.getLong();
        long lsb = bb.getLong();

        msb &= 0xFFFFFFFFFFFF0FFFL;
        msb |= 0x4000L;

        lsb &= 0x3FFFFFFFFFFFFFFFL;
        lsb |= 0x8000000000000000L;

        bh.consume(msb);
        bh.consume(lsb);
    }

    @Benchmark
    public void longs_name_bb(Blackhole bh) {
        final byte[] data = new byte[16];
        randomBytes(data);

        final ByteBuffer bb = ByteBuffer.wrap(data);
//        bb.order(ByteOrder.BIG_ENDIAN);

        long msb = bb.getLong();
        long lsb = bb.getLong();

        msb &= 0xFFFFFFFFFFFF0FFFL;
        msb |= 0x3000L;

        lsb &= 0x3FFFFFFFFFFFFFFFL;
        lsb |= 0x8000000000000000L;

        bh.consume(msb);
        bh.consume(lsb);
    }

    static void randomBytes(byte[] bytes) {
        ThreadLocalRandom tlr = ThreadLocalRandom.current();
        LONGS_ACCESS.set(bytes, 0, tlr.nextLong());
        LONGS_ACCESS.set(bytes, 8, tlr.nextLong());
    }
}