= Benchmark

@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(value = 3, jvmArgsAppend = {"-Xmx1g", "-Xms1g"})
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
public class UninitAlloc {

    static Unsafe U;

    static {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            U = (Unsafe) field.get(null);
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }

    @Param({"1", "100", "10000"})
    int size;

    @Benchmark
    public byte[] java() {
        return new byte[size];
    }

    @Benchmark
    public byte[] reflect() {
        return (byte[]) Array.newInstance(byte.class, size);
    }

    @Benchmark
    public byte[] unsafe() {
        return (byte[]) U.allocateArrayUninit(byte.class, size);
    }

}


== C1

C1 does not have intrinsics, and so Unsafe.allocateArrayUninit is as fast
as normal Java allocations, plus some type selection. This matters on small sizes:

=== Baseline

Benchmark            (size)  Mode  Cnt     Score    Error  Units

UninitAlloc.java          1  avgt   15     4.527 ±  0.061  ns/op
UninitAlloc.java        100  avgt   15    13.598 ±  0.138  ns/op
UninitAlloc.java      10000  avgt   15  1018.850 ± 17.430  ns/op

UninitAlloc.reflect       1  avgt   15    41.418 ±  0.934  ns/op
UninitAlloc.reflect     100  avgt   15    46.592 ±  1.229  ns/op
UninitAlloc.reflect   10000  avgt   15  1059.900 ± 17.508  ns/op

=== Patched

Benchmark            (size)  Mode  Cnt     Score    Error  Units

UninitAlloc.java          1  avgt   15     4.490 ±  0.045  ns/op
UninitAlloc.java        100  avgt   15    13.713 ±  0.209  ns/op
UninitAlloc.java      10000  avgt   15  1036.181 ± 16.784  ns/op

UninitAlloc.reflect       1  avgt   15    42.083 ±  0.272  ns/op
UninitAlloc.reflect     100  avgt   15    48.361 ±  2.461  ns/op
UninitAlloc.reflect   10000  avgt   15  1048.101 ± 17.214  ns/op

UninitAlloc.unsafe       1  avgt   15     18.384 ±  0.110  ns/op
UninitAlloc.unsafe     100  avgt   15     24.385 ±  0.300  ns/op
UninitAlloc.unsafe   10000  avgt   15   1028.560 ± 21.344  ns/op

== C2

C2 provides intrinsics that make reflective accesses as fast as Java instantiations.
The Unsafe.allocateArrayUninit escapes quite a bit of zeroing costs:

=== Baseline

Benchmark            (size)  Mode  Cnt    Score    Error  Units

UninitAlloc.java          1  avgt   15   13.540 ±  1.241  ns/op
UninitAlloc.java        100  avgt   15   13.942 ±  0.195  ns/op
UninitAlloc.java      10000  avgt   15  559.391 ± 11.127  ns/op

UninitAlloc.reflect       1  avgt   15   12.684 ±  0.084  ns/op
UninitAlloc.reflect     100  avgt   15   13.886 ±  0.204  ns/op
UninitAlloc.reflect   10000  avgt   15  554.383 ± 12.152  ns/op


=== Patched

Benchmark            (size)  Mode  Cnt    Score    Error  Units

UninitAlloc.java          1  avgt   15   12.768 ±  0.209  ns/op
UninitAlloc.java        100  avgt   15   13.723 ±  0.172  ns/op
UninitAlloc.java      10000  avgt   15  564.716 ± 14.939  ns/op

UninitAlloc.reflect       1  avgt   15   12.657 ±  0.061  ns/op
UninitAlloc.reflect     100  avgt   15   13.780 ±  0.207  ns/op
UninitAlloc.reflect   10000  avgt   15  562.466 ± 36.413  ns/op

UninitAlloc.unsafe        1  avgt   15    4.195 ±  0.050  ns/op
UninitAlloc.unsafe      100  avgt   15    9.926 ±  0.221  ns/op
UninitAlloc.unsafe    10000  avgt   15   96.759 ±  2.681  ns/op