SerializationConstructorAccessorImpl removed in JDK 24

[avrecko]

See JDK-8327624, this commit, removed SerializationConstructorAccessorImpl altogether.

An update is needed for JDK >= 24.

Following exception happens on doing Repository.get(Model.class) on OpenJDK 24.

Exception in thread "main" java.lang.ExceptionInInitializerError
	at one.nio.serial.GeneratedSerializer.code(GeneratedSerializer.java:111)
	at one.nio.serial.GeneratedSerializer.<init>(GeneratedSerializer.java:57)
	at one.nio.serial.Repository.generateFor(Repository.java:379)
	at one.nio.serial.Repository.get(Repository.java:182)
	at one.nio.serial.gen.MagicAccessor.main(MagicAccessor.java:63)
Caused by: java.lang.IllegalStateException: java.lang.reflect.InvocationTargetException
	at one.nio.serial.gen.DelegateGenerator.<clinit>(DelegateGenerator.java:82)
	... 5 more
Caused by: java.lang.reflect.InvocationTargetException
	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:119)
	at java.base/java.lang.reflect.Method.invoke(Method.java:565)
	at one.nio.serial.gen.DelegateGenerator.defineBootstrapClass(DelegateGenerator.java:89)
	at one.nio.serial.gen.DelegateGenerator.<clinit>(DelegateGenerator.java:78)
	... 5 more
Caused by: java.lang.NoClassDefFoundError: jdk/internal/reflect/SerializationConstructorAccessorImpl
	at java.base/java.lang.ClassLoader.defineClass1(Native Method)
	at java.base/jdk.internal.reflect.DirectMethodHandleAccessor.invoke(DirectMethodHandleAccessor.java:104)
	... 8 more

[avrecko]

I've played a bit with JMH benchmarks. VarHandles are substantially slower than the MagicAccessor approach. Using Unsafe and using field offsets comes close. I observed ~15% lower throughput using Unsafe with fieldOffsets in JMH benchmark. This said they are getting serious about removing functionality of Unsafe in > 26. Looks like they plan on keeping just pageSize, throwException and allocateInstance of Unsafe.

MyBenchmark.directAccess     thrpt       889632067.918          ops/s
MyBenchmark.fieldAccessor    thrpt       102346845.635          ops/s
MyBenchmark.reflectField     thrpt        85963180.752          ops/s
MyBenchmark.unsafeApi        thrpt       787460601.515          ops/s
MyBenchmark.varHandleAccess  thrpt       112638884.311          ops/s

I am still impressed with the MagicAccessor approach. Too bad it looks like it is no longer a viable option. Thoughts on alternatives?

[avrecko]

I've redone the benchmark but this time with everything final. Pretty shocked to see such big differences.

private static final VarHandle varHandle vs private static VarHandle varHandle

MyBenchmark.directAccess     thrpt    3  894389556.107 ±  22643510.914  ops/s
MyBenchmark.fieldAccessor    thrpt    3  894370126.228 ±  18205759.195  ops/s
MyBenchmark.reflectField     thrpt    3  890203777.300 ± 211894902.621  ops/s
MyBenchmark.unsafeApi        thrpt    3  890327594.126 ±   4517196.451  ops/s
MyBenchmark.varHandleAccess  thrpt    3  894259154.384 ±   9698436.361  ops/s

Looks like JIT did some magic in this case. Perhaps VarHandles are indeed a stable alternative to MagicAccessor/Unsafe. Just need to be very careful with finals. Bad performance of VarHandles

[lehvolk]

Could you please share a benchmark if possible?

[avrecko]

Could you please share a benchmark of possible?

It is very basic. Didn't put my thought into it. Just to get a feel for what is going on.

@State(Scope.Thread)
public class MyBenchmark {

    private final Foo foo;

    public MyBenchmark() {
        foo = new Foo();
        foo.someField = System.currentTimeMillis();
    }

    public static class Foo {
        private long someField;
    }

    private static final Constructor<?> rawConstructor;

    private static final Constructor<Foo> genericConstructor;

    private static final VarHandle varHandle;

    private static final long unsafeOffsetForSomeField;

    private static final FieldAccessor fieldAccessor;

    private static final Field fieldReflect;

    static {
        rawConstructor = ReflectionFactory.getReflectionFactory().newConstructorForSerialization(Foo.class);
        genericConstructor = (Constructor<Foo>) ReflectionFactory.getReflectionFactory().newConstructorForSerialization(Foo.class);
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        try {
            varHandle = MethodHandles.privateLookupIn(Foo.class, lookup).findVarHandle(Foo.class, "someField", long.class);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }


        try {
            fieldReflect = Foo.class.getDeclaredField("someField");
            fieldReflect.setAccessible(true);
            fieldAccessor = ReflectionFactory.getReflectionFactory().newFieldAccessor(fieldReflect, false);
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        }

        unsafeOffsetForSomeField = objectFieldOffset(Foo.class, "someField");
    }

    @Benchmark
    public void canary() {
    }

    @Benchmark
    public Foo allocateDirect() {
        return new Foo();
    }

    @Benchmark
    public Foo allocateNonGenericConstructor() throws InvocationTargetException, InstantiationException, IllegalAccessException {
        return (Foo) rawConstructor.newInstance();
    }

    @Benchmark
    public Foo allocateGenericConstructor() throws Exception {
        return genericConstructor.newInstance();
    }

    @Benchmark
    public Foo allocateViaUnsafe() throws Exception {
        return (Foo) UnsafeApi.allocateInstance(Foo.class);
    }


    @Benchmark
    public long directAccess() throws Exception {
        foo.someField += 1_000;
        return foo.someField;
    }

    @Benchmark
    public long varHandleAccess() throws Exception {
        long a = (long) varHandle.get(foo);
        a += 1000;
        varHandle.set(foo, a);
        return a;
    }

    @Benchmark
    public long fieldAccessor() throws Exception {
        long a = fieldAccessor.getLong (foo);
        a += 1_000;
        fieldAccessor.setLong(foo, a);
        return fieldAccessor.getLong(foo);
    }

    @Benchmark
    public long reflectField() throws Exception {
        long a = fieldReflect.getLong(foo);
        a += 1_000;
        fieldReflect.set(foo, a);
        return fieldReflect.getLong(foo);
    }


    @Benchmark
    public long unsafeApiFieldAccess() throws Exception {
        long a = getLong(foo, unsafeOffsetForSomeField);
        a += 1_000;
        putLong(foo, unsafeOffsetForSomeField, a);
        return getLong(foo, unsafeOffsetForSomeField);
    }

}

[avrecko]

Also requires when run by JMH: --jvmArgs "--add-opens java.base/jdk.internal.reflect=ALL-UNNAMED --add-opens java.base/jdk.internal.misc=ALL-UNNAMED" and in build tool

<compilerArgs>
    <arg>--add-exports</arg>
   <arg>java.base/jdk.internal.reflect=ALL-UNNAMED</arg>
</compilerArgs>

[avrecko]

I think the cleanest solution would probably be to not do anything with reflection but just generate with ASM clean java pojo code, calling getters and setters. But this might break some stuff. I don't know. Just thinking out loud.

[lehvolk]

MagicAccessor is used for skipping bytecode verification. Since jvm still preserve mechanism for instantiating class without calling init method then fix should switch generated bytecode to this solution